@emilia-protocol/gate 0.10.0 → 0.13.0

package/dist/network-witness.d.ts

@@ -0,0 +1,167 @@
+export declare const NETWORK_WITNESS_VERSION = "EP-GATE-NETWORK-WITNESS-v1";
+export declare const NETWORK_WITNESS_ACCEPTANCE_VERSION = "EP-GATE-NETWORK-WITNESS-ACCEPTANCE-v1";
+export declare const NETWORK_WITNESS_DOMAIN = "EP-GATE-NETWORK-WITNESS-v1\0";
+export declare const NETWORK_WITNESS_EVENTS: readonly string[];
+type NetworkWitnessChecks = {
+    shape: boolean;
+    pin: boolean;
+    signature: boolean;
+    action_binding: boolean;
+    freshness: boolean;
+    config_binding: boolean;
+};
+type NetworkWitnessVerifyFailure = {
+    verified: false;
+    accepted: false;
+    reason: string;
+    checks: NetworkWitnessChecks;
+    statement_digest?: undefined;
+    stream_id?: undefined;
+    sequence?: undefined;
+    action_digest?: undefined;
+    event?: undefined;
+    observed_at?: undefined;
+    witness_id?: undefined;
+    capture_point_id?: undefined;
+    limitation?: undefined;
+};
+type NetworkWitnessVerifySuccess = {
+    verified: true;
+    accepted: true;
+    reason: null;
+    statement_digest: string;
+    stream_id: string;
+    sequence: number;
+    action_digest: string;
+    event: string;
+    observed_at: string;
+    witness_id: string;
+    capture_point_id: string;
+    checks: NetworkWitnessChecks;
+    limitation: string;
+};
+type NetworkWitnessVerifyResult = NetworkWitnessVerifyFailure | NetworkWitnessVerifySuccess;
+type NetworkWitnessVerifyOptions = {
+    pinnedWitnesses?: any[];
+    expectedActionDigest?: string;
+    expectedEvent?: string;
+    now?: number;
+    maxAgeSec?: number;
+    maxFutureSkewSec?: number;
+};
+type NetworkWitnessAcceptanceOptions = {
+    allowEphemeralStore?: boolean;
+    expectedStatementDigest?: string;
+    expectedActionDigest?: string;
+    expectedEvent?: string;
+    now?: number;
+    maxAgeSec?: number;
+    maxFutureSkewSec?: number;
+};
+interface NetworkWitnessSequenceStore {
+    durable: boolean;
+    advance: (streamId: string, sequence: number, statementDigest: string) => Promise<{
+        accepted: boolean;
+        reason: string | null;
+    }>;
+}
+type NetworkWitnessAcceptOptions = NetworkWitnessVerifyOptions & {
+    sequenceStore?: NetworkWitnessSequenceStore;
+    allowEphemeralStore?: boolean;
+};
+export declare function networkWitnessDigest(statement: any): string;
+/** Duplicate-key-safe parser for an untrusted serialized witness artifact. */
+export declare function parseNetworkWitnessStatement(raw: any, { maxBytes }?: {
+    maxBytes?: number | undefined;
+}): any;
+/** Create a signed observation. The public key is intentionally not embedded. */
+export declare function signNetworkWitnessStatement(input: any, privateKey: any): Readonly<{
+    signature: Readonly<{
+        algorithm: "Ed25519";
+        key_id: any;
+        statement_digest: string;
+        signature_b64u: string;
+    }>;
+    '@version': string;
+    witness: {
+        id: any;
+        key_id: any;
+        capture_point_id: any;
+    };
+    observation: {
+        byte_count?: any;
+        flow_digest?: any;
+        sequence: any;
+        observed_at: any;
+        event: any;
+        direction: any;
+        action_digest: any;
+    };
+    deployment: {
+        attestation_ref?: any;
+        config_digest: any;
+    };
+    privacy: {
+        payload_captured: boolean;
+    };
+    limitations: string[];
+}>;
+/**
+ * Offline signature and context verification. This function never throws on a
+ * presenter-controlled statement. Sequence consumption is a separate online
+ * operation performed by acceptNetworkWitnessStatement.
+ */
+export declare function verifyNetworkWitnessStatement(statement: any, options?: NetworkWitnessVerifyOptions): NetworkWitnessVerifyResult;
+export declare function createMemoryWitnessSequenceStore(): {
+    durable: boolean;
+    advance(streamId: any, sequence: any, statementDigest: any): Promise<{
+        accepted: boolean;
+        reason: string;
+    } | {
+        accepted: boolean;
+        reason: null;
+    }>;
+    snapshot(): any[];
+};
+/**
+ * Validate an ingestion result supplied through a relying-party-trusted option.
+ * This does not authenticate presenter-controlled JSON; callers must never move
+ * an untrusted bundle field into this trust channel.
+ */
+export declare function validateTrustedNetworkWitnessAcceptance(result: any, options?: NetworkWitnessAcceptanceOptions): {
+    verified: boolean;
+    accepted: boolean;
+    consumed: boolean;
+    reason: string;
+} | {
+    verified: boolean;
+    accepted: boolean;
+    consumed: boolean;
+    reason: null;
+    acceptance_version: string;
+    statement_digest: any;
+    stream_id: any;
+    sequence: any;
+    action_digest: any;
+    event: any;
+    observed_at: any;
+    witness_id: any;
+    capture_point_id: any;
+    sequence_store_durable: boolean;
+};
+/** Verify and atomically advance a witness stream for online ingestion. */
+export declare function acceptNetworkWitnessStatement(statement: any, options?: NetworkWitnessAcceptOptions): Promise<any>;
+declare const _default: {
+    NETWORK_WITNESS_VERSION: string;
+    NETWORK_WITNESS_ACCEPTANCE_VERSION: string;
+    NETWORK_WITNESS_EVENTS: readonly string[];
+    parseNetworkWitnessStatement: typeof parseNetworkWitnessStatement;
+    networkWitnessDigest: typeof networkWitnessDigest;
+    signNetworkWitnessStatement: typeof signNetworkWitnessStatement;
+    verifyNetworkWitnessStatement: typeof verifyNetworkWitnessStatement;
+    acceptNetworkWitnessStatement: typeof acceptNetworkWitnessStatement;
+    validateTrustedNetworkWitnessAcceptance: typeof validateTrustedNetworkWitnessAcceptance;
+    createMemoryWitnessSequenceStore: typeof createMemoryWitnessSequenceStore;
+};
+export default _default;
+//# sourceMappingURL=network-witness.d.ts.map

package/dist/network-witness.d.ts.map

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

package/dist/network-witness.js

@@ -0,0 +1,520 @@
+// @ts-nocheck
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Independent, privacy-minimized observation evidence for EMILIA Gate.
+ *
+ * A network witness is deliberately NOT an enforcement point. It can prove a
+ * pinned sensor observed bytes associated with an action digest at a named
+ * capture point. It cannot prove the action was authorized, blocked, executed,
+ * or physically completed. Keeping that boundary in the artifact prevents a
+ * passive TAP from being marketed as a firewall.
+ */
+import crypto from 'node:crypto';
+import { canonicalize } from './execution-binding.js';
+import { strictJsonGate } from './strict-json.js';
+export const NETWORK_WITNESS_VERSION = 'EP-GATE-NETWORK-WITNESS-v1';
+export const NETWORK_WITNESS_ACCEPTANCE_VERSION = 'EP-GATE-NETWORK-WITNESS-ACCEPTANCE-v1';
+export const NETWORK_WITNESS_DOMAIN = `${NETWORK_WITNESS_VERSION}\0`;
+export const NETWORK_WITNESS_EVENTS = Object.freeze([
+    'request_observed',
+    'response_observed',
+    'effect_observed',
+]);
+const DIGEST_RE = /^sha256:[0-9a-f]{64}$/;
+const DIRECTIONS = new Set(['ingress', 'egress', 'internal']);
+const RFC3339 = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,9}))?Z$/;
+function strictInstantMs(value) {
+    if (typeof value !== 'string')
+        return NaN;
+    const match = value.match(RFC3339);
+    if (!match)
+        return NaN;
+    const [, year, month, day, hour, minute, second] = match;
+    const base = new Date(0);
+    base.setUTCFullYear(Number(year), Number(month) - 1, Number(day));
+    base.setUTCHours(Number(hour), Number(minute), Number(second), 0);
+    if (base.toISOString().slice(0, 19) !== `${year}-${month}-${day}T${hour}:${minute}:${second}`)
+        return NaN;
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : NaN;
+}
+function isPlainObject(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function exactKeys(value, allowed) {
+    return isPlainObject(value) && Object.keys(value).every((key) => allowed.has(key));
+}
+function nonEmptyString(value, max = 256) {
+    return typeof value === 'string' && value.length > 0 && value.length <= max && !/[\u0000-\u001f\u007f]/.test(value);
+}
+function digest(value) {
+    return typeof value === 'string' && DIGEST_RE.test(value);
+}
+function sha256(bytes) {
+    return crypto.createHash('sha256').update(bytes).digest('hex');
+}
+function decodeBase64Url(value, maxBytes) {
+    if (typeof value !== 'string' || value.length === 0 || !/^[A-Za-z0-9_-]+$/.test(value))
+        return null;
+    try {
+        const bytes = Buffer.from(value, 'base64url');
+        if (bytes.length === 0 || bytes.length > maxBytes || bytes.toString('base64url') !== value)
+            return null;
+        return bytes;
+    }
+    catch {
+        return null;
+    }
+}
+function keyIdFor(key) {
+    const der = crypto.createPublicKey(key).export({ type: 'spki', format: 'der' });
+    return `ep:witness-key:sha256:${sha256(der).slice(0, 16)}`;
+}
+function signingBytes(body) {
+    return Buffer.from(NETWORK_WITNESS_DOMAIN + canonicalize(body), 'utf8');
+}
+function unsigned(statement) {
+    if (!isPlainObject(statement))
+        throw new TypeError('network witness statement must be an object');
+    const { signature: _signature, ...body } = statement;
+    return body;
+}
+export function networkWitnessDigest(statement) {
+    return `sha256:${sha256(signingBytes(unsigned(statement)))}`;
+}
+/** Duplicate-key-safe parser for an untrusted serialized witness artifact. */
+export function parseNetworkWitnessStatement(raw, { maxBytes = 64 * 1024 } = {}) {
+    if (typeof raw !== 'string' || !Number.isSafeInteger(maxBytes) || maxBytes < 1
+        || Buffer.byteLength(raw, 'utf8') > maxBytes)
+        return null;
+    const gated = strictJsonGate(raw);
+    if (!gated.ok)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        return isPlainObject(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function validateBody(body) {
+    if (!exactKeys(body, new Set(['@version', 'witness', 'observation', 'deployment', 'privacy', 'limitations']))) {
+        return 'statement_shape_invalid';
+    }
+    if (body['@version'] !== NETWORK_WITNESS_VERSION)
+        return 'version_invalid';
+    if (!exactKeys(body.witness, new Set(['id', 'key_id', 'capture_point_id'])))
+        return 'witness_shape_invalid';
+    if (!nonEmptyString(body.witness.id) || !nonEmptyString(body.witness.key_id)
+        || !nonEmptyString(body.witness.capture_point_id))
+        return 'witness_identity_invalid';
+    if (!exactKeys(body.observation, new Set([
+        'sequence', 'observed_at', 'event', 'direction', 'action_digest', 'flow_digest', 'byte_count',
+    ])))
+        return 'observation_shape_invalid';
+    if (!Number.isSafeInteger(body.observation.sequence) || body.observation.sequence < 0)
+        return 'sequence_invalid';
+    if (!Number.isFinite(strictInstantMs(body.observation.observed_at)))
+        return 'observed_at_invalid';
+    if (!NETWORK_WITNESS_EVENTS.includes(body.observation.event))
+        return 'event_invalid';
+    if (!DIRECTIONS.has(body.observation.direction))
+        return 'direction_invalid';
+    if (!digest(body.observation.action_digest))
+        return 'action_digest_invalid';
+    if (body.observation.flow_digest !== undefined && !digest(body.observation.flow_digest))
+        return 'flow_digest_invalid';
+    if (body.observation.byte_count !== undefined
+        && (!Number.isSafeInteger(body.observation.byte_count) || body.observation.byte_count < 0))
+        return 'byte_count_invalid';
+    if (!exactKeys(body.deployment, new Set(['config_digest', 'attestation_ref'])))
+        return 'deployment_shape_invalid';
+    if (!digest(body.deployment.config_digest))
+        return 'config_digest_invalid';
+    if (body.deployment.attestation_ref !== undefined && !digest(body.deployment.attestation_ref)) {
+        return 'attestation_ref_invalid';
+    }
+    if (!exactKeys(body.privacy, new Set(['payload_captured'])))
+        return 'privacy_shape_invalid';
+    if (body.privacy.payload_captured !== false)
+        return 'payload_capture_forbidden';
+    if (!Array.isArray(body.limitations) || body.limitations.length < 2 || body.limitations.length > 8
+        || body.limitations.some((item) => !nonEmptyString(item, 512)))
+        return 'limitations_invalid';
+    try {
+        canonicalize(body);
+    }
+    catch {
+        return 'canonical_body_invalid';
+    }
+    return null;
+}
+/** Create a signed observation. The public key is intentionally not embedded. */
+export function signNetworkWitnessStatement(input, privateKey) {
+    if (!privateKey)
+        throw new TypeError('privateKey is required');
+    const keyId = input?.key_id ?? keyIdFor(privateKey);
+    const body = {
+        '@version': NETWORK_WITNESS_VERSION,
+        witness: {
+            id: input?.witness_id,
+            key_id: keyId,
+            capture_point_id: input?.capture_point_id,
+        },
+        observation: {
+            sequence: input?.sequence,
+            observed_at: input?.observed_at,
+            event: input?.event,
+            direction: input?.direction,
+            action_digest: input?.action_digest,
+            ...(input?.flow_digest !== undefined ? { flow_digest: input.flow_digest } : {}),
+            ...(input?.byte_count !== undefined ? { byte_count: input.byte_count } : {}),
+        },
+        deployment: {
+            config_digest: input?.config_digest,
+            ...(input?.attestation_ref !== undefined ? { attestation_ref: input.attestation_ref } : {}),
+        },
+        privacy: { payload_captured: false },
+        limitations: [
+            'This artifact proves only that a pinned witness key signed an observation at a named capture point.',
+            'A passive network witness does not authorize, block, execute, or prove the physical outcome of an action.',
+            'Coverage and completeness depend on the relying party pinning the capture topology and expected witness set.',
+            'Rollback detection begins at a relying-party-pinned stream checkpoint; first-seen sequence numbers are not self-authenticating history.',
+        ],
+    };
+    const invalid = validateBody(body);
+    if (invalid)
+        throw new TypeError(invalid);
+    const statementDigest = networkWitnessDigest(body);
+    return Object.freeze({
+        ...body,
+        signature: Object.freeze({
+            algorithm: 'Ed25519',
+            key_id: keyId,
+            statement_digest: statementDigest,
+            signature_b64u: crypto.sign(null, signingBytes(body), privateKey).toString('base64url'),
+        }),
+    });
+}
+function findPin(pins, witness) {
+    if (!Array.isArray(pins))
+        return null;
+    return pins.find((pin) => isPlainObject(pin)
+        && pin.witness_id === witness.id
+        && pin.key_id === witness.key_id
+        && Array.isArray(pin.capture_point_ids)
+        && pin.capture_point_ids.includes(witness.capture_point_id)) ?? null;
+}
+/**
+ * Offline signature and context verification. This function never throws on a
+ * presenter-controlled statement. Sequence consumption is a separate online
+ * operation performed by acceptNetworkWitnessStatement.
+ */
+export function verifyNetworkWitnessStatement(statement, options = {}) {
+    const fail = (reason, checks = {}) => ({
+        verified: false,
+        accepted: false,
+        reason,
+        checks: {
+            shape: false,
+            pin: false,
+            signature: false,
+            action_binding: false,
+            freshness: false,
+            config_binding: false,
+            ...checks,
+        },
+    });
+    try {
+        if (!isPlainObject(statement)
+            || !exactKeys(statement, new Set(['@version', 'witness', 'observation', 'deployment', 'privacy', 'limitations', 'signature']))) {
+            return fail('statement_shape_invalid');
+        }
+        const body = unsigned(statement);
+        const invalid = validateBody(body);
+        if (invalid)
+            return fail(invalid);
+        if (!exactKeys(statement.signature, new Set(['algorithm', 'key_id', 'statement_digest', 'signature_b64u']))) {
+            return fail('signature_shape_invalid', { shape: true });
+        }
+        if (statement.signature.algorithm !== 'Ed25519'
+            || statement.signature.key_id !== body.witness.key_id
+            || !digest(statement.signature.statement_digest)
+            || !nonEmptyString(statement.signature.signature_b64u, 512)) {
+            return fail('signature_envelope_invalid', { shape: true });
+        }
+        const pin = findPin(options.pinnedWitnesses, body.witness);
+        if (!pin || !nonEmptyString(pin.public_key, 4096))
+            return fail('witness_key_unpinned', { shape: true });
+        if (!Array.isArray(pin.config_digests) || pin.config_digests.length === 0
+            || !pin.config_digests.includes(body.deployment.config_digest)) {
+            return fail('witness_config_unpinned', { shape: true, pin: true });
+        }
+        if (options.expectedActionDigest !== undefined
+            && body.observation.action_digest !== options.expectedActionDigest) {
+            return fail('action_digest_mismatch', { shape: true, pin: true, config_binding: true });
+        }
+        if (options.expectedEvent !== undefined && body.observation.event !== options.expectedEvent) {
+            return fail('event_mismatch', { shape: true, pin: true, config_binding: true });
+        }
+        const now = options.now === undefined ? Date.now() : Number(options.now);
+        const maxAgeSec = options.maxAgeSec === undefined ? 300 : options.maxAgeSec;
+        const maxFutureSkewSec = options.maxFutureSkewSec === undefined ? 30 : options.maxFutureSkewSec;
+        if (!Number.isFinite(now) || !Number.isSafeInteger(maxAgeSec) || maxAgeSec < 0
+            || !Number.isSafeInteger(maxFutureSkewSec) || maxFutureSkewSec < 0) {
+            return fail('verification_profile_invalid', { shape: true, pin: true, config_binding: true });
+        }
+        const observedMs = strictInstantMs(body.observation.observed_at);
+        if (observedMs > now + (maxFutureSkewSec * 1000)) {
+            return fail('observation_from_future', { shape: true, pin: true, action_binding: true, config_binding: true });
+        }
+        if (now - observedMs > maxAgeSec * 1000) {
+            return fail('observation_stale', { shape: true, pin: true, action_binding: true, config_binding: true });
+        }
+        const computedDigest = networkWitnessDigest(body);
+        if (computedDigest !== statement.signature.statement_digest) {
+            return fail('statement_digest_mismatch', {
+                shape: true, pin: true, action_binding: true, freshness: true, config_binding: true,
+            });
+        }
+        let publicKey;
+        try {
+            const keyBytes = decodeBase64Url(pin.public_key, 4096);
+            if (!keyBytes)
+                throw new TypeError('invalid base64url key');
+            publicKey = crypto.createPublicKey({
+                key: keyBytes,
+                type: 'spki',
+                format: 'der',
+            });
+            if (publicKey.asymmetricKeyType !== 'ed25519')
+                throw new TypeError('witness key must be Ed25519');
+        }
+        catch {
+            return fail('pinned_key_invalid', {
+                shape: true, pin: true, action_binding: true, freshness: true, config_binding: true,
+            });
+        }
+        const signature = decodeBase64Url(statement.signature.signature_b64u, 64);
+        if (!signature || signature.length !== 64) {
+            return fail('signature_invalid', {
+                shape: true, pin: true, action_binding: true, freshness: true, config_binding: true,
+            });
+        }
+        if (!crypto.verify(null, signingBytes(body), publicKey, signature)) {
+            return fail('signature_invalid', {
+                shape: true, pin: true, action_binding: true, freshness: true, config_binding: true,
+            });
+        }
+        return {
+            verified: true,
+            accepted: true,
+            reason: null,
+            statement_digest: computedDigest,
+            stream_id: `${body.witness.id}\0${body.witness.capture_point_id}`,
+            sequence: body.observation.sequence,
+            action_digest: body.observation.action_digest,
+            event: body.observation.event,
+            observed_at: body.observation.observed_at,
+            witness_id: body.witness.id,
+            capture_point_id: body.witness.capture_point_id,
+            checks: {
+                shape: true,
+                pin: true,
+                signature: true,
+                action_binding: true,
+                freshness: true,
+                config_binding: true,
+            },
+            limitation: 'Observation is not authorization, enforcement, execution, or physical truth.',
+        };
+    }
+    catch {
+        return fail('hostile_input_refused');
+    }
+}
+export function createMemoryWitnessSequenceStore() {
+    const streams = new Map();
+    return {
+        durable: false,
+        async advance(streamId, sequence, statementDigest) {
+            const previous = streams.get(streamId);
+            if (previous) {
+                if (previous.equivocated === true) {
+                    return { accepted: false, reason: 'sequence_equivocation' };
+                }
+                if (sequence < previous.sequence)
+                    return { accepted: false, reason: 'sequence_rollback' };
+                if (sequence === previous.sequence) {
+                    if (previous.digest === statementDigest) {
+                        return { accepted: false, reason: 'statement_replay' };
+                    }
+                    streams.set(streamId, { ...previous, equivocated: true });
+                    return { accepted: false, reason: 'sequence_equivocation' };
+                }
+            }
+            streams.set(streamId, { sequence, digest: statementDigest, equivocated: false });
+            return { accepted: true, reason: null };
+        },
+        snapshot() { return [...streams.entries()].map(([stream_id, value]) => ({ stream_id, ...value })); },
+    };
+}
+function acceptanceResult(verified, { accepted, consumed, reason, sequenceStoreDurable, }) {
+    return Object.freeze({
+        ...verified,
+        acceptance_version: NETWORK_WITNESS_ACCEPTANCE_VERSION,
+        accepted,
+        consumed,
+        reason,
+        sequence_store_durable: sequenceStoreDurable === true,
+        ...(isPlainObject(verified.checks) ? { checks: Object.freeze({ ...verified.checks }) } : {}),
+    });
+}
+/**
+ * Validate an ingestion result supplied through a relying-party-trusted option.
+ * This does not authenticate presenter-controlled JSON; callers must never move
+ * an untrusted bundle field into this trust channel.
+ */
+export function validateTrustedNetworkWitnessAcceptance(result, options = {}) {
+    const fail = (reason, fields = {}, statementVerified = false) => ({
+        verified: statementVerified === true,
+        accepted: false,
+        consumed: false,
+        reason,
+        ...fields,
+    });
+    try {
+        if (!isPlainObject(result)
+            || result.acceptance_version !== NETWORK_WITNESS_ACCEPTANCE_VERSION) {
+            return fail('trusted_witness_acceptance_invalid');
+        }
+        const common = {
+            acceptance_version: NETWORK_WITNESS_ACCEPTANCE_VERSION,
+            statement_digest: result.statement_digest,
+            stream_id: result.stream_id,
+            sequence: result.sequence,
+            action_digest: result.action_digest,
+            event: result.event,
+            observed_at: result.observed_at,
+            witness_id: result.witness_id,
+            capture_point_id: result.capture_point_id,
+            sequence_store_durable: result.sequence_store_durable === true,
+        };
+        const statementVerified = result.verified === true
+            && digest(common.statement_digest) && digest(common.action_digest)
+            && Number.isSafeInteger(common.sequence) && common.sequence >= 0
+            && nonEmptyString(common.witness_id) && nonEmptyString(common.capture_point_id)
+            && common.stream_id === `${common.witness_id}\0${common.capture_point_id}`
+            && NETWORK_WITNESS_EVENTS.includes(common.event)
+            && Number.isFinite(strictInstantMs(common.observed_at));
+        if (result.accepted !== true || result.consumed !== true) {
+            return fail(nonEmptyString(result.reason) ? result.reason : 'trusted_witness_acceptance_rejected', common, statementVerified);
+        }
+        if (!statementVerified || result.reason !== null) {
+            return fail('trusted_witness_acceptance_invalid');
+        }
+        if (!common.sequence_store_durable && options.allowEphemeralStore !== true) {
+            return fail('durable_sequence_store_required', common);
+        }
+        if (options.expectedStatementDigest !== undefined) {
+            if (!digest(options.expectedStatementDigest))
+                return fail('verification_profile_invalid', common);
+            if (common.statement_digest !== options.expectedStatementDigest) {
+                return fail('witness_acceptance_digest_mismatch', common);
+            }
+        }
+        if (options.expectedActionDigest !== undefined
+            && common.action_digest !== options.expectedActionDigest) {
+            return fail('action_digest_mismatch', common);
+        }
+        if (options.expectedEvent !== undefined && common.event !== options.expectedEvent) {
+            return fail('event_mismatch', common);
+        }
+        const now = options.now === undefined ? Date.now() : Number(options.now);
+        const maxAgeSec = options.maxAgeSec === undefined ? 300 : options.maxAgeSec;
+        const maxFutureSkewSec = options.maxFutureSkewSec === undefined ? 30 : options.maxFutureSkewSec;
+        if (!Number.isFinite(now) || !Number.isSafeInteger(maxAgeSec) || maxAgeSec < 0
+            || !Number.isSafeInteger(maxFutureSkewSec) || maxFutureSkewSec < 0) {
+            return fail('verification_profile_invalid', common);
+        }
+        const observedMs = strictInstantMs(common.observed_at);
+        if (observedMs > now + (maxFutureSkewSec * 1000))
+            return fail('observation_from_future', common);
+        if (now - observedMs > maxAgeSec * 1000)
+            return fail('observation_stale', common);
+        return {
+            ...common,
+            verified: true,
+            accepted: true,
+            consumed: true,
+            reason: null,
+        };
+    }
+    catch {
+        return fail('trusted_witness_acceptance_invalid');
+    }
+}
+/** Verify and atomically advance a witness stream for online ingestion. */
+export async function acceptNetworkWitnessStatement(statement, options = {}) {
+    const verified = verifyNetworkWitnessStatement(statement, options);
+    if (!verified.accepted) {
+        return acceptanceResult(verified, {
+            accepted: false,
+            consumed: false,
+            reason: verified.reason,
+            sequenceStoreDurable: false,
+        });
+    }
+    const store = options.sequenceStore;
+    if (!store || typeof store.advance !== 'function'
+        || (store.durable !== true && options.allowEphemeralStore !== true)) {
+        return acceptanceResult(verified, {
+            accepted: false,
+            consumed: false,
+            reason: 'durable_sequence_store_required',
+            sequenceStoreDurable: false,
+        });
+    }
+    try {
+        const advanced = await store.advance(verified.stream_id, verified.sequence, verified.statement_digest);
+        if (!isPlainObject(advanced) || advanced.accepted !== true || advanced.reason !== null) {
+            return acceptanceResult(verified, {
+                accepted: false,
+                consumed: false,
+                reason: nonEmptyString(advanced?.reason) ? advanced.reason : 'sequence_store_refused',
+                sequenceStoreDurable: store.durable === true,
+            });
+        }
+        return acceptanceResult(verified, {
+            accepted: true,
+            consumed: true,
+            reason: null,
+            sequenceStoreDurable: store.durable === true,
+        });
+    }
+    catch {
+        return acceptanceResult(verified, {
+            accepted: false,
+            consumed: false,
+            reason: 'sequence_store_unavailable',
+            sequenceStoreDurable: store.durable === true,
+        });
+    }
+}
+export default {
+    NETWORK_WITNESS_VERSION,
+    NETWORK_WITNESS_ACCEPTANCE_VERSION,
+    NETWORK_WITNESS_EVENTS,
+    parseNetworkWitnessStatement,
+    networkWitnessDigest,
+    signNetworkWitnessStatement,
+    verifyNetworkWitnessStatement,
+    acceptNetworkWitnessStatement,
+    validateTrustedNetworkWitnessAcceptance,
+    createMemoryWitnessSequenceStore,
+};
+//# sourceMappingURL=network-witness.js.map