device-identity: what a machine is, as a chain of signed statements checked offline (manufacturer credential, owners, firmware attestation, anchored on 28001; 175/175 with the AIP-23 verifier); conformance: the device-bundle vectors and the rules that cover them; control-plane console; README
This commit is contained in:
1 parent
5fb38c5d0b
commit
54028e07f4
215 files changed
+77436
-56
No files matched your search
@@ -7,8 +7,10 @@
|
||||
// verifier still accepts when damaged: the optional and the unread)
|
||||
// node proba-conformance.mjs --control-negativ [--online] [--doar <rule id prefix>]
|
||||
// every rule planted out of its verifier, one at a time: the vectors that
|
||||
// name the rule, and only they, must fail; plus the controls of the
|
||||
// runner, of the coverage gate and of the rule derivation
|
||||
// name the rule, and only they, must fail; then the HALVES of the device
|
||||
// verifier (one condition of a compound check planted out: exactly the
|
||||
// vectors written for it must fail); plus the controls of the runner,
|
||||
// of the coverage gate and of the rule derivation
|
||||
// node proba-conformance.mjs --pe-loc a MEASUREMENT, not a gate: each check site planted out alone; how many
|
||||
// of the sites the vectors reach
|
||||
//
|
||||
@@ -19,6 +21,7 @@ import fs from 'node:fs'; import os from 'node:os'; import path from 'node:path'
|
||||
import { deriva, hartaPublica, VERIFICATOARE, MODULE, VERIFY_PROOF, FINALITY_SITES, NEJUDECATE_IDENTITY, incarca, marcajul } from './reguli.mjs';
|
||||
import { incarcaVectorii, ruleazaSuita } from './conformance.mjs';
|
||||
import { aplica, plicuriKinds } from './genereaza-vectori.mjs';
|
||||
import { PLANTARI as PLANTARI_DEVICE } from '../device-identity/plantari-device.mjs';
|
||||
|
||||
const AICI = path.dirname(fileURLToPath(import.meta.url));
|
||||
const a = process.argv.slice(2); const online = a.includes('--online'); const control = a.includes('--control-negativ'); const peLoc = a.includes('--pe-loc');
|
||||
@@ -55,6 +58,90 @@ const PLANT_VP = {
|
||||
signature: [" const s = env.signature;\n", " const s = env.signature;\n if (String(1) === '1') return level('signature', 'PASSED', 'planted out');\n"],
|
||||
finality: ["env.notarization ? 'FAILED' : 'ABSENT'", "(env.notarization && String(1) === '2') ? 'FAILED' : 'ABSENT'"],
|
||||
};
|
||||
/**
|
||||
* The halves of the device verifier: the name of a planting of its negative control (plantari-device.mjs: one condition of a
|
||||
* compound check taken out, or two checks that guard the same thing taken out together) -> the device-bundle vectors that must
|
||||
* fail under it, and only they. The whole-rule control above cannot see these: with a rule taken out whole, every vector of the
|
||||
* rule fails, whichever half it was written for.
|
||||
*/
|
||||
const JUMATATI_DEVICE = {
|
||||
'one half of the hybrid signature is enough': ['sold-once.firmware-signature'],
|
||||
'the type of the device key is not checked': ['attestation-only.attestation-key', 'manufacture-only.device-key'],
|
||||
'the device key is accepted in any base64 text (its canonical form is not required)': ['attestation-only.attestation-key-not-canonical', 'manufacture-only.device-key-not-canonical'],
|
||||
'a hybrid signature of a link is accepted in any base64 text': ['chain-only.transfer-signature-not-canonical'],
|
||||
'the attestation signature is accepted in any base64 text': ['sold-once.attestation-signature-not-canonical'],
|
||||
"the manufacturer's signature is accepted in any base64 text": ['manufacture-only.manufacture-signature-not-canonical'],
|
||||
'identities are compared by their keys alone (the id half of the comparison taken out)': ['manufacture-only.manufacture-holder-other-id'],
|
||||
'identities are compared by their id alone (the keys half of the comparison taken out)': ['manufacture-only.manufacture-holder-other-keys'],
|
||||
'a manufacture credential that has not begun is accepted': ['manufacture-only.manufacture-window-not-yet'],
|
||||
'an expired manufacture credential is accepted': ['manufacture-only.manufacture-window'],
|
||||
'a recall list of another manufacturer is believed': ['recall-list-of-another-manufacturer.partial'],
|
||||
'an expired recall list is read as current': ['recall-list-expired.partial', 'recall-list-unreadable-beside-a-clean-one.partial'],
|
||||
'a recall list whose validity is not a time is dropped in silence': ['recall-list-unreadable-beside-a-clean-one.partial'],
|
||||
'a hardware root in the manufacture credential passes in silence': ['manufacture-hardware-root.partial'],
|
||||
'the id of who signed a release is not derived from its keys': ['release-only.firmware-signer-id'],
|
||||
'with two firmware policies the loosest floor holds': ['sold-once.firmware-rollback-second-policy'],
|
||||
'a retraction is lifted by a policy that does not list it': ['sold-once.firmware-retracted-second-policy'],
|
||||
'a retraction written in upper case is not seen': ['sold-once.firmware-retracted-upper-case'],
|
||||
'a firmware policy of a stranger is believed': ['sold-once.firmware-signer'],
|
||||
'a firmware policy of another model is believed': ['policy-of-another-model.partial'],
|
||||
'a firmware policy of a version this verifier does not read is dropped in silence': ['policy-of-another-version-beside-a-clean-one.partial'],
|
||||
'an expired firmware policy is read as current': ['policy-expired.partial', 'policy-validity-unreadable-beside-a-clean-one.partial'],
|
||||
'a firmware policy that has not begun is read as current': ['policy-not-yet.partial'],
|
||||
'a retracted entry that is not a digest is read as nothing retracted': ['policy-unreadable-beside-a-clean-one.partial', 'policy-unreadable.partial'],
|
||||
'a floor that is not a whole number is read as a floor': ['policy-floor-unreadable-beside-a-clean-one.partial'],
|
||||
'a policy whose validity is not a time is dropped in silence': ['policy-validity-unreadable-beside-a-clean-one.partial'],
|
||||
'a policy that cannot be read passes in silence': ['policy-floor-unreadable-beside-a-clean-one.partial', 'policy-of-another-version-beside-a-clean-one.partial', 'policy-unreadable-beside-a-clean-one.partial', 'policy-unreadable.partial', 'policy-validity-unreadable-beside-a-clean-one.partial'],
|
||||
'the Proof of Software attestation is not required to list the image': ['with-software.firmware-software'],
|
||||
'the Proof of Software attestation is not required to be the one named': ['with-software.firmware-software-not-the-one-named'],
|
||||
'the id of who GIVES a transfer is not derived from its keys': ['chain-unrooted.transfer-ids-giver'],
|
||||
'the id of who RECEIVES a transfer is not derived from its keys': ['chain-only.transfer-ids'],
|
||||
'the position of a transfer is not required': ['chain-only.transfer-prev-position'],
|
||||
'a transfer is not required to name the link before it': ['chain-only.transfer-prev', 'sold-once.manufacture-signature-and-chain'],
|
||||
'a transfer may be dated in the future': ['chain-only.transfer-time-future'],
|
||||
'a transfer may be dated before the link before it': ['chain-only.transfer-time'],
|
||||
'the id of who grants an authorization is not derived from its keys': ['grant-only.authorization-owner-id'],
|
||||
"an authorization that has not begun on the verifier's clock is accepted": ['sold-once.authorization-window-begins-after-tolerance'],
|
||||
"an authorization that ended on the verifier's clock is accepted": ['sold-once.authorization-window-ended-between'],
|
||||
'an authorization that had not begun when the device attested is accepted': ['sold-once.authorization-window-after-attestation'],
|
||||
'an authorization that ends before the time of the attestation is accepted': ['sold-once.authorization-window-ends-before-attestation'],
|
||||
'the authorization is not judged at the time of the attestation at all': ['sold-once.authorization-window-after-attestation', 'sold-once.authorization-window-ends-before-attestation'],
|
||||
'the beginning of an authorization is not judged at all': ['sold-once.authorization-window-after-attestation', 'sold-once.authorization-window-begins-after-tolerance', 'sold-once.authorization-window-not-yet'],
|
||||
"the manufacturer's retirement, and the owner's, are lifted like a suspension": ['bought-back.status-retired-first-ownership', 'resold.status-retired-by-manufacturer', 'retired-then-active.status-retired', 'sold-once.status-retired', 'sold-once.status-retired-by-owner', 'sold-once.status-retired-by-owner-no-head', 'sold-once.status-retired-date-not-a-time', 'sold-once.status-retired-dated-just-ahead'],
|
||||
"the manufacturer's records stop counting once the device is sold": ['resold.status-retired-by-manufacturer', 'retired-then-active.status-retired', 'sold-once.status-retired', 'sold-once.status-retired-date-not-a-time', 'sold-once.status-retired-dated-just-ahead', 'status-record-of-another-version.partial', 'suspension-lifted.status-suspended-by-manufacturer'],
|
||||
'anyone can write a status record': ['retired-by-a-stranger.valid', 'status-of-a-stranger.partial'],
|
||||
'a record of a PREVIOUS owner binds the owner of now': ['resold-after-retirement.valid', 'resold-after-suspension.valid', 'resold-seller-retires-after.valid'],
|
||||
"the owner's retirement and suspension count only under the current ownership head": ['bought-back.status-retired-first-ownership', 'bought-back.status-suspended-first-ownership', 'sold-once.status-retired-by-owner-no-head'],
|
||||
'an "active" record of the owner is believed under any ownership head': ['bought-back-active-of-first-ownership.partial'],
|
||||
'a record of who may give it that cannot be read is ignored (the registry is read as clean)': ['status-record-of-another-version.partial'],
|
||||
'a record of another version, or with a state the verifier does not know, is read as one of this version': ['status-record-of-another-version.partial'],
|
||||
'a record of another device is applied to this one': ['retirement-of-another-device.valid'],
|
||||
'DOUBLE: a status record under an id its keys do not derive is applied (the derivation in the status loop AND the id half of the comparison, both out)': ['manufacture-only.manufacture-holder-other-id', 'retired-under-an-id-not-derived.valid'],
|
||||
"a suspension is lifted by another signer's later record": ['suspension-lifted.status-suspended-by-manufacturer'],
|
||||
'a suspension expires with its record': ['sold-once.status-suspended-record-expired'],
|
||||
'an expired "active" record is believed': ['active-record-expired.partial'],
|
||||
'of two records with one number the laxer holds': ['sold-once.status-suspended-same-number'],
|
||||
'a record dated in the future is applied': ['retirement-not-yet-in-effect.valid'],
|
||||
"a record dated just ahead of the verifier's clock is given no tolerance": ['sold-once.status-retired-dated-just-ahead'],
|
||||
'a retirement whose date cannot be read is dropped': ['sold-once.status-retired-date-not-a-time'],
|
||||
'the clone check compares the device id alone (the key half taken out)': ['sold-once.attestation-device-claimed-id'],
|
||||
'an attestation dated in the future is accepted up to the allowed age': ['sold-once.freshness-ahead'],
|
||||
'an attestation dated in the future is accepted, however far': ['sold-once.freshness-ahead'],
|
||||
'an old attestation is accepted, however old': ['sold-once.freshness'],
|
||||
'an attestation dated ahead is given no tolerance': ['attested-just-ahead.valid', 'sold-once.authorization-window-begins-after-tolerance', 'sold-once.authorization-window-ends-before-attestation'],
|
||||
'the sequence the device attests is not compared with the release': ['sold-once.attestation-firmware-sequence'],
|
||||
'the digest the device attests is not compared with the release': ['sold-once.attestation-firmware-digest'],
|
||||
'a hardware root in the attestation passes in silence': ['hardware-root.partial'],
|
||||
'the envelope is not bound to this attestation (its hash)': ['witnessed.witness-envelope-of-another'],
|
||||
'the envelope is not bound to this device (its id)': ['witnessed.witness-envelope-other-device'],
|
||||
'the envelope is not required to hash to its statementHash': ['witnessed.witness-envelope'],
|
||||
'a claim of notarization passes for a reading': ['notarization-not-read.partial', 'reading-of-another-envelope.partial'],
|
||||
'a reading of another envelope is taken for this one': ['reading-of-another-envelope.partial'],
|
||||
'a reading whose time is in milliseconds is taken for one in seconds': ['reading-in-milliseconds.partial'],
|
||||
'a reading that cannot be read passes in silence': ['reading-in-milliseconds.partial'],
|
||||
'a bundle of another version is read': ['sold-once.form-version'],
|
||||
'transfers that are not a list are read': ['sold-once.form-transfers-not-a-list'],
|
||||
};
|
||||
/** Writes the planted copy of a rule's verifier beside the original; returns { copie, env } or { stricat }. `loc` plants one site only. */
|
||||
function planteaza(verifier, sursa, loc = null) {
|
||||
const d = VERIFICATOARE[verifier];
|
||||
@@ -98,7 +185,7 @@ const ramase = () => [...Object.values(MODULE).map((m) => path.dirname(fileURLTo
|
||||
* @returns {{ cazuri: number, aruncate: string[], acceptate: string[] }} acceptate = the paths (without array positions) whose damage was accepted
|
||||
*/
|
||||
async function malformate() {
|
||||
const R = await incarca('risc'), C = await incarca('chitanta'), P = await incarca('piata'), B = await incarca('baza'), SC = await incarca('sidecar'), AR = await incarca('arbore'), L = await incarca('ledger'), ID = await incarca('identity'); const clona = (x) => JSON.parse(JSON.stringify(x));
|
||||
const R = await incarca('risc'), C = await incarca('chitanta'), P = await incarca('piata'), B = await incarca('baza'), SC = await incarca('sidecar'), AR = await incarca('arbore'), L = await incarca('ledger'), ID = await incarca('identity'), DV = await incarca('device'); const clona = (x) => JSON.parse(JSON.stringify(x));
|
||||
const J = { 'payment-risk': (i) => R.judeca(i.policy, i.inputs).decision === 'ALLOW', 'payment-receipt': (i) => C.verificaChitanta(i.receipt, { policy: i.policy, inputs: i.inputs, tx: i.tx, receipt: i.txReceipt }).verdict === 'VALID', 'market-timeline': (i) => P.judeca(i).verdict === 'VALID',
|
||||
'dataset-record': (i) => B.verificaInregistrare(i.record, i.commitment).ok, 'dataset-answer': (i) => B.verificaRaspuns(i.answer, i.commitment).verdict === 'VALID', 'dataset-consistency': (i) => B.verificaConsistentaVersiuni(i.proof, i.older, i.newer).ok,
|
||||
// the verifiers enrolled after the first four (2026-10-05), called the way the adapter calls them; ai-trust is not here: each case would run the reference verifier several times
|
||||
@@ -107,19 +194,26 @@ async function malformate() {
|
||||
'audit-consistency': (i) => AR.verificaConsistenta(i.proof, { vechi: i.older, nou: i.newer, semnatar: i.signer || null }).ok,
|
||||
'agent-ledger': (i) => { const o = { policy: i.policy, policyHash: i.policyHash, anchors: i.anchors || [], notBefore: i.notBefore === undefined ? null : i.notBefore, revocations: i.revocations || [] }; if (i.maxTime !== undefined) o.maxTime = i.maxTime; return L.verifyLedger(i.ledger, o).ok; },
|
||||
// identity (2026-10-05): the presentation and everything handed with it; the verifier's own configuration is left out below
|
||||
'identity-presentation': (i) => { const o = { now: i.now }; for (const k of ['audience', 'nonce', 'trustedIssuers', 'statusLists', 'revocations', 'maxAgeS']) if (i[k] !== undefined) o[k] = i[k]; const r = ID.verifyPresentation(i.presentation, o); return r.valid && !r.unjudged.some((c) => NEJUDECATE_IDENTITY[c]); } }; // accepted = what the suite would call VALID, not PARTIAL
|
||||
'identity-presentation': (i) => { const o = { now: i.now }; for (const k of ['audience', 'nonce', 'trustedIssuers', 'statusLists', 'revocations', 'maxAgeS']) if (i[k] !== undefined) o[k] = i[k]; const r = ID.verifyPresentation(i.presentation, o); return r.valid && !r.unjudged.some((c) => NEJUDECATE_IDENTITY[c]); }, // accepted = what the suite would call VALID, not PARTIAL
|
||||
// a device bundle (2026-10-05) and everything handed with it; the verifier's own configuration (its clock, the manufacturers it trusts, the lists themselves) is left out below
|
||||
'device-bundle': (i) => { const o = { now: i.now }; for (const k of ['nonce', 'audience', 'trustedManufacturers', 'statusLists', 'firmwarePolicies', 'statusRecords', 'softwareAttestation', 'anchors', 'maxAgeS']) if (i[k] !== undefined) o[k] = i[k]; return DV.verifyDevice(i.bundle, o).verdict === 'VALID'; } };
|
||||
const cai = (x, p = []) => (x !== null && typeof x === 'object' ? [p, ...Object.keys(x).flatMap((k) => cai(x[k], [...p, Array.isArray(x) ? Number(k) : k]))] : [p]).filter((q) => q.length);
|
||||
const VAL = [null, 'x', 7, [], {}]; let cazuri = 0; const aruncate = [], acceptate = [];
|
||||
const VAL = [null, 'x', 7, [], {}]; let cazuri = 0; const aruncate = [], acceptate = [], sarite = [];
|
||||
// a vector whose input is larger than MARE characters is not damaged path by path: thousands of paths, each judged over the whole input
|
||||
// (a chain of 64 transfers), would take longer than everything else here together. It is counted and named, not passed in silence.
|
||||
const MARE = 300000;
|
||||
for (const v of vectori) {
|
||||
if (!J[v.artifact] || v.expected.verdict === 'INVALID' || v.requires.length) continue;
|
||||
if (JSON.stringify(v.input).length > MARE) { sarite.push(v.id); continue; }
|
||||
const inp = clona(v.input); if (v.artifact === 'market-timeline') delete inp.spec;
|
||||
for (const p of cai(inp)) { if (p[0] === 'policy' && v.artifact.startsWith('payment-')) continue;
|
||||
if (v.artifact === 'identity-presentation' && (p[0] === 'trustedIssuers' || (p.length === 1 && (p[0] === 'statusLists' || p[0] === 'revocations')))) continue;
|
||||
if (v.artifact === 'device-bundle' && (['trustedManufacturers', 'now', 'maxAgeS'].includes(p[0]) || (p.length === 1 && ['statusLists', 'firmwarePolicies', 'statusRecords', 'anchors'].includes(p[0])))) continue;
|
||||
for (const op of ['remove', 0, 1, 2, 3, 4]) { const c = clona(inp); let o = c; for (const k of p.slice(0, -1)) o = o[k]; const k = p[p.length - 1];
|
||||
if (op === 'remove') { if (Array.isArray(o)) o.splice(k, 1); else delete o[k]; } else { if (JSON.stringify(o[k]) === JSON.stringify(VAL[op])) continue; o[k] = clona(VAL[op]); }
|
||||
cazuri++; try { if (J[v.artifact](c)) acceptate.push(v.artifact + ':' + p.filter((x) => typeof x !== 'number').join('.')); } catch (e) { aruncate.push(v.id + ' ' + p.join('.') + ' <- ' + (op === 'remove' ? 'removed' : JSON.stringify(VAL[op])) + ': ' + String(e.message).slice(0, 60)); } } }
|
||||
}
|
||||
return { cazuri, aruncate, acceptate };
|
||||
return { cazuri, aruncate, acceptate, sarite, MARE };
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -198,7 +292,7 @@ if (!control && !peLoc) {
|
||||
|
||||
console.log('D. a malformed artifact is refused by name, never thrown at the reader');
|
||||
{ const m = await malformate();
|
||||
cer(m.cazuri > 1000 && !m.aruncate.length, `${m.cazuri} malformed inputs (every path removed or replaced) given to the module verifiers: each got a verdict, none threw`, m.aruncate.slice(0, 3).join(' | ') + (m.aruncate.length > 3 ? ' ... ' + m.aruncate.length + ' in all' : ''));
|
||||
cer(m.cazuri > 1000 && !m.aruncate.length, `${m.cazuri} malformed inputs (every path removed or replaced) given to the module verifiers: each got a verdict, none threw` + (m.sarite.length ? `; NOT damaged this way: ${m.sarite.length} vector(s) whose input is larger than ${m.MARE} characters (${m.sarite.join(', ')})` : ''), m.aruncate.slice(0, 3).join(' | ') + (m.aruncate.length > 3 ? ' ... ' + m.aruncate.length + ' in all' : ''));
|
||||
const cai = [...new Set(m.acceptate)].sort(); const peFel = {}; for (const c of cai) { const k = c.split(':')[0]; peFel[k] = (peFel[k] || 0) + 1; }
|
||||
rand('INFO', `measured, not a gate: ${m.acceptate.length} of them were still accepted, at ${cai.length} distinct paths (${Object.entries(peFel).map(([k, n]) => k + ' ' + n).join(', ')}): parts a verifier treats as optional (the transaction facts of a receipt, the envelope of a timeline) and fields no rule reads; --acceptate lists them`);
|
||||
if (a.includes('--acceptate')) for (const c of cai) console.log(' ' + c); }
|
||||
@@ -229,6 +323,31 @@ if (!control && !peLoc) {
|
||||
} finally { for (const f of ramase()) fs.rmSync(f, { force: true }); }
|
||||
for (const c of cazuri.filter((x) => x.numaiOnline && !online)) rand('NEMASURAT', `${c.id}: its vectors need testnet 28001 (--online)`);
|
||||
if (filtru) rand('NEMASURAT', `${toate.length - cazuri.length} rules left out by --doar`);
|
||||
// A rule taken out WHOLE says nothing about each condition of a check made of several. For the device verifier the conditions are
|
||||
// planted out one at a time (the plantings are those of its own negative control, read from its plantari-device.mjs, not typed
|
||||
// again here): the vectors written for that condition, and only they, must fail.
|
||||
console.log('CONTROL of the halves (device verifier): one condition of a compound check planted out; exactly the vectors written for it must fail');
|
||||
if (filtru && !filtru.startsWith('device')) rand('NEMASURAT', `the ${Object.keys(JUMATATI_DEVICE).length} halves of the device verifier left out by --doar`);
|
||||
else {
|
||||
const p = fileURLToPath(MODULE.device.url); const src = fs.readFileSync(p, 'utf8'); const lista = Object.entries(JUMATATI_DEVICE); let buneJ = 0;
|
||||
try {
|
||||
const rez = await inParalel(lista.map(([nume], k) => async () => {
|
||||
const pl = PLANTARI_DEVICE.find((x) => x[0] === nume && x[1] === path.basename(p)); if (!pl) return { stricat: 'no planting of this name in plantari-device.mjs' };
|
||||
const de = [pl[2]].flat(), cu = [pl[3]].flat(); let text = src;
|
||||
for (const [j, d] of de.entries()) { if (src.split(d).length !== 2 || text.split(d).length !== 2) return { stricat: `pattern ${j + 1} is not in the device verifier exactly once` }; text = text.replace(d, () => cu[j]); }
|
||||
const copie = path.join(path.dirname(p), `_plantat-conf-${process.pid}-jum-${k}.mjs`); fs.writeFileSync(copie, text);
|
||||
try { return await suitaAsync({ [MODULE.device.env]: copie }, { artefacte: ['device-bundle'] }); } finally { fs.rmSync(copie, { force: true }); }
|
||||
}));
|
||||
lista.forEach(([nume, ast], k) => {
|
||||
const r = rez[k]; const asteptate = ast.map((x) => 'device-bundle/' + x).sort(); const lipsa = asteptate.filter((id) => !vectori.some((v) => v.id === id));
|
||||
if (r.stricat || r.eroare || lipsa.length) return rand('STRICAT', `${nume}: ${r.stricat || r.eroare || 'names vectors that are not in the set: ' + lipsa.join(', ')}`);
|
||||
const cazute = r.rezultate.filter((x) => x.stare === 'FAIL').map((x) => x.id).sort(); const stricate = r.rezultate.filter((x) => x.stare === 'BROKEN').map((x) => x.id);
|
||||
const ok = asteptate.length > 0 && cazute.join() === asteptate.join() && !stricate.length; if (ok) buneJ++;
|
||||
rand(ok ? 'VERDE' : stricate.length ? 'STRICAT' : 'ROSU', `${nume}: ${cazute.length} vector(s) fail` + (ok ? `, exactly the ${asteptate.length} written for it (${ast.join(', ')})` : `; expected exactly [${asteptate.join(', ')}], failed [${cazute.join(', ')}]` + (stricate.length ? `, broken [${stricate.join(', ')}]` : '')));
|
||||
});
|
||||
} finally { for (const f of ramase()) fs.rmSync(f, { force: true }); }
|
||||
console.log(`CONTROL of the halves: ${buneJ} of ${lista.length} conditions proven load-bearing through their vectors`);
|
||||
}
|
||||
console.log('CONTROL of the instruments');
|
||||
{ // the runner can fail: an implementation that calls everything VALID
|
||||
const stub = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'aere-conf-stub-')), 'stub.mjs');
|
||||
|
||||
Reference in new issue
Block a user