@emilia-protocol/gate 0.11.0 → 0.13.0

package/dist/eg1-conformance.d.ts

@@ -0,0 +1,286 @@
+export declare const EG1_VERSION = "EG-1";
+/**
+ * Mint a GENUINE WebAuthn ECDSA-P256 device signoff over an authorization
+ * context — the same structure @emilia-protocol/verify verifyWebAuthnSignoff
+ * checks. This is what earns a receipt its class_a tier: a real per-signer
+ * assertion, not a self-asserted `outcome` string. Used to build the Class-A and
+ * quorum evidence the EG-1 harness embeds so the Gate can CRYPTOGRAPHICALLY
+ * credit the tier.
+ * @param {{ actionHash?: string, approver?: string, issuedAtMs?: number, nonce?: string, prevContextHash?: string }} [opts]
+ */
+export declare function mintDeviceSignoff({ actionHash, approver, issuedAtMs, nonce, prevContextHash, }?: {
+    actionHash?: string;
+    approver?: string;
+    issuedAtMs?: number;
+    nonce?: string;
+    prevContextHash?: string;
+}): {
+    signoff: {
+        '@type': string;
+        context: {
+            prev_context_hash?: string | undefined;
+            ep_version: string;
+            context_type: string;
+            action_hash: string | undefined;
+            policy: string;
+            nonce: string;
+            approver: string | undefined;
+            initiator: string;
+            issued_at: string;
+            expires_at: string;
+        };
+        webauthn: {
+            authenticator_data: string;
+            client_data_json: string;
+            signature: string;
+        };
+        approver_public_key: string;
+    };
+    approver_public_key: string;
+    context: {
+        prev_context_hash?: string | undefined;
+        ep_version: string;
+        context_type: string;
+        action_hash: string | undefined;
+        policy: string;
+        nonce: string;
+        approver: string | undefined;
+        initiator: string;
+        issued_at: string;
+        expires_at: string;
+    };
+};
+/**
+ * Mint a GENUINE EP-QUORUM-v1 evidence document: N distinct humans, each on a
+ * distinct device key, each with a real WebAuthn assertion bound to the SAME
+ * action_hash, within a window. verifyQuorum returns valid for it. This is what
+ * earns a receipt its `quorum` tier — never a bare {signers,threshold} block.
+ * @param {{ actionHash?: string, threshold?: number, approvers?: Array<{ role: string, approver: string }>, issuedAtMs?: number }} [opts]
+ */
+export declare function mintQuorumEvidence({ actionHash, threshold, approvers, issuedAtMs, }?: {
+    actionHash?: string;
+    threshold?: number;
+    approvers?: Array<{
+        role: string;
+        approver: string;
+    }>;
+    issuedAtMs?: number;
+}): {
+    '@type': string;
+    action_hash: string | undefined;
+    policy: {
+        mode: string;
+        required: number;
+        approvers: {
+            role: string;
+            approver: string;
+        }[];
+        distinct_humans: boolean;
+        window_sec: number;
+    };
+    members: {
+        role: string;
+        approver_public_key: string;
+        signoff: {
+            '@type': string;
+            context: {
+                prev_context_hash?: string | undefined;
+                ep_version: string;
+                context_type: string;
+                action_hash: string | undefined;
+                policy: string;
+                nonce: string;
+                approver: string | undefined;
+                initiator: string;
+                issued_at: string;
+                expires_at: string;
+            };
+            webauthn: {
+                authenticator_data: string;
+                client_data_json: string;
+                signature: string;
+            };
+        };
+    }[];
+};
+export declare const EG1_DEFAULT_SELECTOR: Readonly<{
+    protocol: "mcp";
+    tool: "release_payment";
+}>;
+export declare const EG1_DEFAULT_ACTION: Readonly<{
+    action_type: "payment.release";
+    amount_usd: 40000;
+    currency: "USD";
+    payment_instruction_id: "pi_eg1_40000";
+    beneficiary_account_hash: "sha256:eg1-beneficiary";
+}>;
+export declare const EG1_CHECKS: readonly {
+    id: string;
+    title: string;
+}[];
+/**
+ * Create an EG-1 harness: a throwaway issuer key + a receipt minter for the
+ * scenarios. Configure the subject's gate to trust `publicKey` for the run.
+ */
+export declare function createEg1Harness({ now, action, idPrefix, }?: {
+    now?: () => number;
+    action?: Record<string, unknown>;
+    idPrefix?: string;
+}): {
+    publicKey: string;
+    approverKeys: {
+        'ep:key:eg1:class-a': {
+            approver_id: string;
+            public_key: string;
+            key_class: string;
+        };
+        'ep:key:eg1:class-a-2': {
+            approver_id: string;
+            public_key: string;
+            key_class: string;
+        };
+        'ep:key:eg1:controller': {
+            approver_id: string;
+            public_key: string;
+            key_class: string;
+        };
+    };
+    quorumPolicy: {
+        mode: string;
+        required: number;
+        distinct_humans: boolean;
+        window_sec: number;
+        approvers: {
+            role: string;
+            approver: string;
+        }[];
+    };
+    mint: ({ outcome, quorum, fakeQuorum, tamper, extra, }?: {
+        outcome?: "allow" | "allow_with_signoff";
+        quorum?: {
+            threshold?: number;
+            signers?: any[];
+        } | null;
+        fakeQuorum?: boolean;
+        tamper?: Record<string, any> | null;
+        extra?: Record<string, any>;
+    }) => {
+        '@version': string;
+        payload: {
+            receipt_id: string;
+            subject: string;
+            issuer: string;
+            created_at: string;
+            claim: Record<string, any>;
+            quorum?: any;
+            assurance_proof?: any;
+            signoff?: any;
+            approver_public_key?: string;
+        };
+        signature: {
+            algorithm: string;
+            value: string;
+        };
+    };
+    action: Record<string, unknown>;
+    actionHash: string;
+    now: () => number;
+    rpId: string;
+    allowedOrigins: string[];
+};
+/**
+ * Adapt an @emilia-protocol/gate instance into an EG-1 `invoke`. The gate must
+ * have been built trusting the harness public key. Uses gate.run() so the
+ * execution proof + reliance packet are produced on the allowed path.
+ */
+export declare function makeGateInvoke(gate: any, { selector, action }?: {
+    selector?: Readonly<{
+        protocol: "mcp";
+        tool: "release_payment";
+    }> | undefined;
+    action?: Readonly<{
+        action_type: "payment.release";
+        amount_usd: 40000;
+        currency: "USD";
+        payment_instruction_id: "pi_eg1_40000";
+        beneficiary_account_hash: "sha256:eg1-beneficiary";
+    }> | undefined;
+}): ({ receipt, observedAction }: {
+    receipt: any;
+    observedAction: any;
+}) => Promise<{
+    allowed: boolean;
+    status: any;
+    reason: any;
+    decisionHash?: undefined;
+    execution?: undefined;
+    packet?: undefined;
+} | {
+    allowed: boolean;
+    status: number;
+    reason: any;
+    decisionHash: any;
+    execution: any;
+    packet: any;
+}>;
+/**
+ * Drive a subject through the eight EG-1 checks and return a JSON report.
+ * @param {object} [o]
+ * @param {(scenario:object)=>Promise<object>} [o.invoke] the integration under test
+ * @param {object} [o.harness] from createEg1Harness()
+ * @param {object} [o.action] the high-risk action (defaults to the harness action)
+ */
+export declare function runEg1({ invoke, harness, action, }?: {
+    invoke?: (scenario: {
+        receipt: any;
+        observedAction: any;
+    }) => Promise<{
+        allowed: boolean;
+        status?: number | null;
+        reason?: string | null;
+        decisionHash?: string | null;
+        execution?: {
+            authorizes_decision?: string | null;
+        } | null;
+        packet?: {
+            verdict?: string | null;
+        } | null;
+    }>;
+    harness?: ReturnType<typeof createEg1Harness>;
+    action?: Record<string, any>;
+}): Promise<{
+    standard: string;
+    passed: boolean;
+    badge: string;
+    summary: {
+        passed: number;
+        total: number;
+    };
+    checks: any[];
+    generated_at: string;
+}>;
+declare const _default: {
+    EG1_VERSION: string;
+    EG1_CHECKS: readonly {
+        id: string;
+        title: string;
+    }[];
+    EG1_DEFAULT_ACTION: Readonly<{
+        action_type: "payment.release";
+        amount_usd: 40000;
+        currency: "USD";
+        payment_instruction_id: "pi_eg1_40000";
+        beneficiary_account_hash: "sha256:eg1-beneficiary";
+    }>;
+    EG1_DEFAULT_SELECTOR: Readonly<{
+        protocol: "mcp";
+        tool: "release_payment";
+    }>;
+    createEg1Harness: typeof createEg1Harness;
+    makeGateInvoke: typeof makeGateInvoke;
+    runEg1: typeof runEg1;
+    mintDeviceSignoff: typeof mintDeviceSignoff;
+    mintQuorumEvidence: typeof mintQuorumEvidence;
+};
+export default _default;
+//# sourceMappingURL=eg1-conformance.d.ts.map

package/dist/eg1-conformance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eg1-conformance.d.ts","sourceRoot":"","sources":["../src/eg1-conformance.ts"],"names":[],"mappings":"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"}

package/dist/eg1-conformance.js

@@ -0,0 +1,379 @@
+// @ts-nocheck
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * EG-1 Conformance — the binary artifact that turns "we adopted EMILIA Gate"
+ * from a claim into a test result.
+ *
+ * The question EG-1 answers: *does your integration actually ENFORCE the gate,
+ * or are you only claiming it?* An integration earns EG-1 only if it
+ * demonstrably:
+ *   1. refuses a high-risk action with NO receipt (428);
+ *   2. refuses a software-tier receipt on a Class-A action;
+ *   3. refuses when the observed execution drifts from the authorized fields;
+ *   4. RUNS the action for a valid Class-A/quorum receipt;
+ *   5. refuses a replay of the same receipt;
+ *   6. refuses a tampered receipt;
+ *   7. emits an execution proof bound to the authorization decision;
+ *   8. produces a reliance packet whose verdict is "rely".
+ *
+ * This module is pure (no dependency on index.js, so no import cycle): it owns a
+ * throwaway issuer keypair, mints the scenario receipts, and drives any
+ * "subject" through the eight checks. A subject is an async `invoke` function
+ * representing one attempt at the guarded dangerous action:
+ *
+ *   invoke({ receipt, observedAction }) -> {
+ *     allowed: boolean, status: number, reason: string,
+ *     // present only on an allowed run:
+ *     decisionHash?: string, execution?: { authorizes_decision }, packet?: { verdict }
+ *   }
+ *
+ * For integrations built on @emilia-protocol/gate, `makeGateInvoke(gate, ...)`
+ * produces a conformant `invoke` from `gate.run()`. Custom integrations (an HTTP
+ * service, a different language) implement `invoke` themselves and configure
+ * their gate to trust `harness.publicKey` for the run.
+ */
+import crypto from 'node:crypto';
+export const EG1_VERSION = 'EG-1';
+// Same sorted-key canonical JSON the receipt signature is computed over.
+const canon = (v) => (v == null ? JSON.stringify(v)
+    : Array.isArray(v) ? `[${v.map(canon).join(',')}]`
+        : typeof v === 'object' ? `{${Object.keys(v).sort().map((k) => JSON.stringify(k) + ':' + canon(v[k])).join(',')}}`
+            : JSON.stringify(v));
+const sha256Hex = (v) => crypto.createHash('sha256').update(v, 'utf8').digest('hex');
+const sha256Bytes = (v) => crypto.createHash('sha256').update(v).digest();
+const RP_ID = 'emiliaprotocol.ai';
+const RP_ORIGIN = `https://www.${RP_ID}`;
+/**
+ * Mint a GENUINE WebAuthn ECDSA-P256 device signoff over an authorization
+ * context — the same structure @emilia-protocol/verify verifyWebAuthnSignoff
+ * checks. This is what earns a receipt its class_a tier: a real per-signer
+ * assertion, not a self-asserted `outcome` string. Used to build the Class-A and
+ * quorum evidence the EG-1 harness embeds so the Gate can CRYPTOGRAPHICALLY
+ * credit the tier.
+ * @param {{ actionHash?: string, approver?: string, issuedAtMs?: number, nonce?: string, prevContextHash?: string }} [opts]
+ */
+export function mintDeviceSignoff({ actionHash, approver, issuedAtMs = Date.now(), nonce, prevContextHash = undefined, } = {}) {
+    const signer = crypto.generateKeyPairSync('ec', { namedCurve: 'P-256' });
+    const context = {
+        ep_version: '1.0', context_type: 'ep.signoff.v1',
+        action_hash: actionHash,
+        policy: 'policy_eg1',
+        nonce: nonce || ('sig_' + crypto.randomBytes(16).toString('hex')),
+        approver,
+        initiator: 'ent_agent_eg1',
+        issued_at: new Date(issuedAtMs).toISOString(),
+        expires_at: new Date(issuedAtMs + 5 * 60_000).toISOString(),
+        ...(prevContextHash !== undefined ? { prev_context_hash: prevContextHash } : {}),
+    };
+    const challenge = crypto.createHash('sha256').update(canon(context), 'utf8').digest().toString('base64url');
+    const clientData = Buffer.from(JSON.stringify({ type: 'webauthn.get', challenge, origin: `https://www.${RP_ID}` }), 'utf8');
+    const authData = Buffer.concat([
+        crypto.createHash('sha256').update(RP_ID, 'utf8').digest(),
+        Buffer.from([0x05]), // UP | UV
+        Buffer.from([0, 0, 0, 1]),
+    ]);
+    const signed = Buffer.concat([authData, crypto.createHash('sha256').update(clientData).digest()]);
+    const signature = crypto.sign('sha256', signed, signer.privateKey).toString('base64url');
+    return {
+        signoff: {
+            '@type': 'ep.signoff',
+            context,
+            webauthn: {
+                authenticator_data: authData.toString('base64url'),
+                client_data_json: clientData.toString('base64url'),
+                signature,
+            },
+            approver_public_key: signer.publicKey.export({ type: 'spki', format: 'der' }).toString('base64url'),
+        },
+        approver_public_key: signer.publicKey.export({ type: 'spki', format: 'der' }).toString('base64url'),
+        context,
+    };
+}
+/**
+ * Mint a GENUINE EP-QUORUM-v1 evidence document: N distinct humans, each on a
+ * distinct device key, each with a real WebAuthn assertion bound to the SAME
+ * action_hash, within a window. verifyQuorum returns valid for it. This is what
+ * earns a receipt its `quorum` tier — never a bare {signers,threshold} block.
+ * @param {{ actionHash?: string, threshold?: number, approvers?: Array<{ role: string, approver: string }>, issuedAtMs?: number }} [opts]
+ */
+export function mintQuorumEvidence({ actionHash, threshold = 2, approvers, issuedAtMs = Date.now(), } = {}) {
+    const people = approvers || Array.from({ length: threshold }, (_, i) => ({ role: `approver_${i + 1}`, approver: `ep:approver:eg1_${i + 1}` }));
+    const members = people.map((p, i) => {
+        const s = mintDeviceSignoff({ actionHash, approver: p.approver, issuedAtMs: issuedAtMs + i * 1000 });
+        return { role: p.role, approver_public_key: s.approver_public_key, signoff: { '@type': s.signoff['@type'], context: s.signoff.context, webauthn: s.signoff.webauthn } };
+    });
+    return {
+        '@type': 'ep.quorum',
+        action_hash: actionHash,
+        policy: {
+            mode: 'threshold',
+            required: threshold,
+            approvers: people,
+            distinct_humans: true,
+            window_sec: 900,
+        },
+        members,
+    };
+}
+// The default high-risk action EG-1 exercises: a Class-A money movement, which
+// the default gate manifest guards (selector { protocol:'mcp', tool:'release_payment' }).
+export const EG1_DEFAULT_SELECTOR = Object.freeze({ protocol: 'mcp', tool: 'release_payment' });
+export const EG1_DEFAULT_ACTION = Object.freeze({
+    action_type: 'payment.release',
+    amount_usd: 40000,
+    currency: 'USD',
+    payment_instruction_id: 'pi_eg1_40000',
+    beneficiary_account_hash: 'sha256:eg1-beneficiary',
+});
+export const EG1_CHECKS = Object.freeze([
+    { id: 'missing_receipt_refused', title: 'missing receipt → 428' },
+    { id: 'software_on_classA_refused', title: 'software receipt on Class-A action → refused' },
+    { id: 'execution_drift_refused', title: 'observed execution drift → refused' },
+    { id: 'valid_classA_runs', title: 'valid Class-A/quorum receipt → runs' },
+    { id: 'replay_refused', title: 'same receipt replay → refused' },
+    { id: 'tampered_refused', title: 'tampered receipt → refused' },
+    { id: 'execution_proof_binds', title: 'execution proof binds to authorization decision' },
+    { id: 'reliance_packet_rely', title: 'reliance packet returns verdict "rely"' },
+]);
+/**
+ * Create an EG-1 harness: a throwaway issuer key + a receipt minter for the
+ * scenarios. Configure the subject's gate to trust `publicKey` for the run.
+ */
+export function createEg1Harness({ now = Date.now, action = EG1_DEFAULT_ACTION, idPrefix = 'eg1', } = {}) {
+    const { publicKey, privateKey } = crypto.generateKeyPairSync('ed25519');
+    const pub = publicKey.export({ type: 'spki', format: 'der' }).toString('base64url');
+    const approverA = crypto.generateKeyPairSync('ec', { namedCurve: 'P-256' });
+    const approverA2 = crypto.generateKeyPairSync('ec', { namedCurve: 'P-256' });
+    const approverB = crypto.generateKeyPairSync('ed25519');
+    const approverKeys = {
+        'ep:key:eg1:class-a': {
+            approver_id: 'ep:approver:eg1:cfo',
+            public_key: approverA.publicKey.export({ type: 'spki', format: 'der' }).toString('base64url'),
+            key_class: 'A',
+        },
+        'ep:key:eg1:class-a-2': {
+            approver_id: 'ep:approver:eg1:security-officer',
+            public_key: approverA2.publicKey.export({ type: 'spki', format: 'der' }).toString('base64url'),
+            key_class: 'A',
+        },
+        'ep:key:eg1:controller': {
+            approver_id: 'ep:approver:eg1:controller',
+            public_key: approverB.publicKey.export({ type: 'spki', format: 'der' }).toString('base64url'),
+            key_class: 'B',
+        },
+    };
+    const quorumPolicy = {
+        mode: 'threshold', required: 2, distinct_humans: true, window_sec: 900,
+        approvers: [
+            { role: 'cfo', approver: approverKeys['ep:key:eg1:class-a'].approver_id },
+            { role: 'security_officer', approver: approverKeys['ep:key:eg1:class-a-2'].approver_id },
+        ],
+    };
+    let counter = 0;
+    const nowMs = () => (typeof now === 'function' ? now() : now);
+    // The action_hash the self-contained human device assertions are bound to.
+    // Derived from the action so the signoff/quorum evidence is about THIS action.
+    const actionHash = crypto.createHash('sha256').update(canon(action), 'utf8').digest('hex');
+    function assuranceContext(payload) {
+        return {
+            '@version': 'EP-ASSURANCE-CONTEXT-v1',
+            receipt_id: payload.receipt_id,
+            claim_hash: `sha256:${sha256Hex(canon(payload.claim))}`,
+        };
+    }
+    function classASignoff(digest, { keyId = 'ep:key:eg1:class-a', keyPair = approverA, approver = 'ep:approver:eg1:cfo', } = {}) {
+        const challenge = Buffer.from(digest).toString('base64url');
+        const clientDataJSON = Buffer.from(JSON.stringify({ type: 'webauthn.get', challenge, origin: RP_ORIGIN }), 'utf8');
+        const rpIdHash = crypto.createHash('sha256').update(RP_ID).digest();
+        const authData = Buffer.concat([rpIdHash, Buffer.from([0x05]), Buffer.from([0, 0, 0, 0])]); // UP + UV
+        const signedData = Buffer.concat([authData, sha256Bytes(clientDataJSON)]);
+        return {
+            approver,
+            approver_key_id: keyId,
+            key_class: 'A',
+            webauthn: {
+                authenticator_data: authData.toString('base64url'),
+                client_data_json: clientDataJSON.toString('base64url'),
+                signature: crypto.sign('sha256', signedData, keyPair.privateKey).toString('base64url'),
+            },
+        };
+    }
+    function softwareSignoff(digest) {
+        return {
+            approver: 'ep:approver:eg1:controller',
+            approver_key_id: 'ep:key:eg1:controller',
+            key_class: 'B',
+            signature: crypto.sign(null, digest, approverB.privateKey).toString('base64url'),
+        };
+    }
+    function assuranceProof(payload, quorum) {
+        const context = assuranceContext(payload);
+        const contextHash = `sha256:${sha256Hex(canon(context))}`;
+        const digest = Buffer.from(contextHash.replace(/^sha256:/, ''), 'hex');
+        const threshold = Number(quorum?.threshold ?? quorum?.m ?? 1);
+        const signoffs = [classASignoff(digest)];
+        if (threshold >= 2) {
+            signoffs.push(classASignoff(digest, {
+                keyId: 'ep:key:eg1:class-a-2',
+                keyPair: approverA2,
+                approver: 'ep:approver:eg1:security-officer',
+            }));
+        }
+        return {
+            '@version': 'EP-ASSURANCE-PROOF-v1',
+            context_hash: contextHash,
+            threshold: threshold >= 2 ? threshold : 1,
+            signoffs,
+        };
+    }
+    /**
+     * Mint a scenario receipt.
+     * @param {object} o
+     * @param {'allow'|'allow_with_signoff'} [o.outcome] 'allow'=software; 'allow_with_signoff'
+     *   embeds a REAL WebAuthn device signoff so the receipt cryptographically earns class_a.
+     * @param {object|boolean} [o.quorum] request quorum-tier evidence. Truthy -> a REAL
+     *   EP-QUORUM-v1 doc (distinct humans + distinct keys + per-signer assertions). If an
+     *   object with `threshold`/`signers`, its size sets the quorum size.
+     * @param {boolean} [o.fakeQuorum] embed an UNVERIFIABLE self-asserted quorum block
+     *   ({signers,threshold}) with no per-signer signatures — used to prove the Gate
+     *   REFUSES it (must NOT be credited quorum). For adversarial tests only.
+     * @param {object} [o.tamper] fields assigned to the claim AFTER signing (breaks the signature)
+     * @param {object} [o.extra] extra fields merged into the claim before signing
+    */
+    function mint({ outcome = 'allow_with_signoff', quorum = null, fakeQuorum = false, tamper = null, extra = {}, } = {}) {
+        const approver = outcome === 'allow'
+            ? 'ep:approver:eg1:controller'
+            : 'ep:approver:eg1:cfo';
+        const claim = { ...action, outcome, approver, ...extra };
+        const payload = {
+            receipt_id: `${idPrefix}_${++counter}`,
+            subject: 'agent:eg1-conformance',
+            issuer: 'ep:org:eg1',
+            created_at: new Date(nowMs()).toISOString(),
+            claim,
+        };
+        if (fakeQuorum) {
+            // Self-asserted ONLY — NO members / NO signatures / NO pinned proof. The
+            // Gate must refuse to credit this as quorum (assurance_too_low). For
+            // adversarial tests that prove payload claims are never trusted.
+            payload.quorum = { signers: ['ep:a', 'ep:b'], threshold: 2 };
+        }
+        else if (outcome === 'allow_with_signoff' || quorum) {
+            // Genuine, per-signer-verifiable evidence. The PRIMARY proof is the pinned
+            // EP-ASSURANCE-PROOF-v1 (verified against the harness's pinned approverKeys),
+            // which is what the EG-1 gate/custody path checks. We ALSO embed self-contained
+            // evidence (EP-QUORUM-v1 / WebAuthn device signoff) so a relying party that
+            // does NOT pin keys can still cryptographically credit the tier (DoD audit fix).
+            payload.assurance_proof = assuranceProof(payload, quorum);
+            if (quorum) {
+                const threshold = Number.isInteger(quorum.threshold) ? quorum.threshold
+                    : (Array.isArray(quorum.signers) ? quorum.signers.length : 2);
+                payload.quorum = mintQuorumEvidence({
+                    actionHash,
+                    threshold,
+                    approvers: quorumPolicy.approvers.slice(0, threshold),
+                    issuedAtMs: nowMs(),
+                });
+            }
+            else {
+                const s = mintDeviceSignoff({ actionHash, approver, issuedAtMs: nowMs() });
+                payload.signoff = s.signoff;
+                payload.approver_public_key = s.approver_public_key;
+            }
+        }
+        const value = crypto.sign(null, Buffer.from(canon(payload), 'utf8'), privateKey).toString('base64url');
+        const receipt = { '@version': 'EP-RECEIPT-v1', payload, signature: { algorithm: 'Ed25519', value } };
+        if (tamper)
+            Object.assign(receipt.payload.claim, tamper); // tamper AFTER signing -> signature no longer binds
+        return receipt;
+    }
+    return { publicKey: pub, approverKeys, quorumPolicy, mint, action, actionHash, now: nowMs, rpId: RP_ID, allowedOrigins: [RP_ORIGIN] };
+}
+/**
+ * Adapt an @emilia-protocol/gate instance into an EG-1 `invoke`. The gate must
+ * have been built trusting the harness public key. Uses gate.run() so the
+ * execution proof + reliance packet are produced on the allowed path.
+ */
+export function makeGateInvoke(gate, { selector = EG1_DEFAULT_SELECTOR, action = EG1_DEFAULT_ACTION } = {}) {
+    if (!gate || typeof gate.run !== 'function') {
+        throw new Error('makeGateInvoke requires an EMILIA Gate instance (with .run)');
+    }
+    return async ({ receipt, observedAction }) => {
+        const out = await gate.run({ selector, receipt, observedAction: observedAction ?? action }, async () => ({ eg1: 'side-effect-ran' }));
+        if (!out.ok) {
+            return { allowed: false, status: out.status, reason: out.authorization?.reason ?? 'refused' };
+        }
+        return {
+            allowed: true,
+            status: 200,
+            reason: out.authorization?.reason ?? 'allow',
+            decisionHash: out.authorization?.evidence?.hash ?? null,
+            execution: out.execution ?? null,
+            packet: out.packet ?? null,
+        };
+    };
+}
+const pick = (r) => ({ allowed: !!r.allowed, status: r.status ?? null, reason: r.reason ?? null });
+/**
+ * Drive a subject through the eight EG-1 checks and return a JSON report.
+ * @param {object} [o]
+ * @param {(scenario:object)=>Promise<object>} [o.invoke] the integration under test
+ * @param {object} [o.harness] from createEg1Harness()
+ * @param {object} [o.action] the high-risk action (defaults to the harness action)
+ */
+export async function runEg1({ invoke, harness, action, } = {}) {
+    if (typeof invoke !== 'function')
+        throw new Error('runEg1 requires an invoke(scenario) function');
+    if (!harness || typeof harness.mint !== 'function')
+        throw new Error('runEg1 requires a harness from createEg1Harness()');
+    const act = action || harness.action || EG1_DEFAULT_ACTION;
+    const observed = act;
+    const drift = { ...act, amount_usd: Number(act.amount_usd ?? 0) + 1 };
+    const results = {};
+    const set = (id, pass, observed_) => { results[id] = { pass: !!pass, observed: observed_ }; };
+    // 1. missing receipt → 428
+    let r = await invoke({ receipt: null, observedAction: observed });
+    set('missing_receipt_refused', !r.allowed && r.status === 428, pick(r));
+    // 2. software receipt on a Class-A action → refused
+    r = await invoke({ receipt: harness.mint({ outcome: 'allow' }), observedAction: observed });
+    set('software_on_classA_refused', !r.allowed && /assurance/i.test(r.reason || ''), pick(r));
+    // 3. observed execution drift → refused
+    r = await invoke({ receipt: harness.mint({ outcome: 'allow_with_signoff' }), observedAction: drift });
+    set('execution_drift_refused', !r.allowed && /binding/i.test(r.reason || ''), pick(r));
+    // 4. valid Class-A receipt → runs (capture for 5/7/8)
+    const valid = harness.mint({ outcome: 'allow_with_signoff' });
+    r = await invoke({ receipt: valid, observedAction: observed });
+    const validAllowed = r.allowed === true;
+    set('valid_classA_runs', validAllowed, pick(r));
+    // 7. execution proof binds to the authorization decision
+    const boundOk = validAllowed
+        && !!r.execution && !!r.execution.authorizes_decision
+        && !!r.decisionHash && r.execution.authorizes_decision === r.decisionHash;
+    set('execution_proof_binds', boundOk, {
+        authorizes_decision: r.execution?.authorizes_decision ?? null,
+        decision_hash: r.decisionHash ?? null,
+    });
+    // 8. reliance packet verdict "rely"
+    set('reliance_packet_rely', validAllowed && String(r.packet?.verdict || '').toLowerCase() === 'rely', {
+        verdict: r.packet?.verdict ?? null,
+    });
+    // 5. same receipt replay → refused
+    r = await invoke({ receipt: valid, observedAction: observed });
+    set('replay_refused', !r.allowed && /replay/i.test(r.reason || ''), pick(r));
+    // 6. tampered receipt → refused
+    r = await invoke({ receipt: harness.mint({ outcome: 'allow_with_signoff', tamper: { amount_usd: 9_999_999 } }), observedAction: observed });
+    set('tampered_refused', !r.allowed && r.status === 428, pick(r));
+    const checks = EG1_CHECKS.map((c) => ({ id: c.id, title: c.title, ...results[c.id] }));
+    const passedCount = checks.filter((c) => c.pass).length;
+    const passed = passedCount === checks.length;
+    return {
+        standard: EG1_VERSION,
+        passed,
+        badge: passed ? 'EG-1 Enforced' : 'EG-1 not earned',
+        summary: { passed: passedCount, total: checks.length },
+        checks,
+        generated_at: new Date(harness.now ? harness.now() : Date.now()).toISOString(),
+    };
+}
+export default { EG1_VERSION, EG1_CHECKS, EG1_DEFAULT_ACTION, EG1_DEFAULT_SELECTOR, createEg1Harness, makeGateInvoke, runEg1, mintDeviceSignoff, mintQuorumEvidence };
+//# sourceMappingURL=eg1-conformance.js.map