n8n-nodes-engram 0.8.1 → 0.8.2

package/README.md

@@ -25,7 +25,7 @@
 
 <p align="center">
   <a href="#installation">Installation</a> &middot;
-  <a href="#upgrading-to-v081">Upgrade</a> &middot;
+  <a href="#upgrading-to-v082">Upgrade</a> &middot;
   <a href="#node-reference">Nodes</a> &middot;
   <a href="#storage-backends">Storage</a> &middot;
   <a href="#knowledge-extraction">Extraction</a> &middot;
@@ -101,6 +101,23 @@ npm install n8n-nodes-engram
 
 ---
 
+## Upgrading to v0.8.2
+
+This patch reduces embedded-store processing overhead during automatic capture, memory retrieval and conversation saves. Existing node versions, saved defaults, namespaces and memory policies are preserved. The performance changes require no new setting or node-version upgrade. Installing the package does not enable an automatic-memory profile or start a background worker.
+
+1. Take fresh, consistent workflow and backend-native backups. Preserve complete embedded files or the Neo4j database, producer workflow mapping, storage paths, logical store identity, namespaces, bindings and aliases. Include queue-aware recovery data where durable jobs already exist.
+2. Install `n8n-nodes-engram@0.8.2`, restart n8n and refresh the editor. Begin with an inactive workflow copy and a separately restored store with its logical ownership mapping preserved. Moving an enrolled store to another producer path is not an activation step.
+3. Keep the current model, route, temperature, source mappings and stable event IDs. Verify cold startup, recent conversation, accepted graph-only recall, capture receipts, duplicate events and a conversation with multiple tool calls. Confirm that tool audits remain separate and final turns are saved once.
+4. Expand only after the selected workflow passes. Review passive writers separately. If enabling Autonomous Personal Memory for the first time, the existing [v0.8.0 profile setup](#upgrading-to-v080) and [v0.8.1 configured-budget instructions](#upgrading-to-v081) still apply.
+
+After embedded-store initialization fails, cached-memory reads now report that failure instead of returning empty or stale data. Correct the backing file and retry initialization or restart the workflow; no memory reset is required. A failed initialization must not be treated as successful recall.
+
+Monitor n8n memory use during rollout, particularly with large embedded stores or several active workflows. Faster repeated reads can retain more data in memory between writes. Provider-request latency remains separate from local storage work; this patch does not guarantee a particular response time.
+
+No reset, purge, re-enrollment or bulk re-extraction is required. Prefer reverting explicit workflow/policy settings on the supported binary while preserving newly appended memory. Existing downgrade and mixed-version writer/worker restrictions remain in force. Never restore an old snapshot over newer conversations as routine rollback.
+
+---
+
 ## Upgrading to v0.8.1
 
 This patch adds configurable capture budgets and fixes Memory continuation across tool rounds. Existing node versions, saved defaults, namespaces and memory are preserved. Autonomous Personal Memory uses AI Agent **v3.1** with n8n **2.12.3 / Node.js 22** or **2.44.6 / Node.js 24**.

package/dist/extraction/AutonomousPersonalQualifiedClaimV4.d.ts

@@ -1,5 +1,6 @@
 import { type AutonomousPersonalQualifiedClaimResultV4 } from '../schemas/AutonomousPersonalQualifiedClaimV4.schema';
 import { type AutonomousPersonalTypedSyntaxWorkV1 } from '../schemas/AutonomousPersonalTypedSyntaxV1.schema';
+import { type AutonomousPersonalRecordIntegrityV4FailureReason } from '../schemas/AutonomousPersonalRecordIntegrityV4.schema';
 import type { GraphData } from '../schemas/GraphData.schema';
 import type { AutonomousPersonalClaimIndexCandidateRowsV4 } from '../schemas/AutonomousPersonalClaimIndexCandidateRowsV4.schema';
 declare const indexBrand: unique symbol;
@@ -13,7 +14,16 @@ export declare class AutonomousPersonalClaimIndexV4Error extends Error {
 }
 export declare function createAutonomousPersonalClaimIndexV4(graphValue: unknown, typedSyntaxWork: AutonomousPersonalTypedSyntaxWorkV1, codeOwnedCheck: () => void): AutonomousPersonalClaimIndexV4;
 export declare function getAutonomousPersonalClaimIndexGraphV4(index: AutonomousPersonalClaimIndexV4): GraphData;
+export declare function getRegisteredAutonomousPersonalClaimIndexGraphV4(value: unknown): GraphData | undefined;
 export declare function getAutonomousPersonalClaimIndexCandidateRowsV4(indexValue: unknown, edgeIdValue: unknown): AutonomousPersonalClaimIndexCandidateRowsV4 | null;
 export declare function inspectAutonomousPersonalClaimCreatorV4(indexValue: unknown, edgeIdValue: unknown): AutonomousPersonalQualifiedClaimResultV4;
 export declare function qualifyAutonomousPersonalClaimCreatorV4(indexValue: unknown, requestValue: unknown): AutonomousPersonalQualifiedClaimResultV4;
+export declare class AutonomousPersonalRecordIntegrityV4Error extends Error {
+    readonly reason: AutonomousPersonalRecordIntegrityV4FailureReason;
+    constructor(reason: AutonomousPersonalRecordIntegrityV4FailureReason);
+}
+export declare function assertAutonomousPersonalRecordIntegrityV4(graphValue: unknown, typedSyntaxWork: AutonomousPersonalTypedSyntaxWorkV1, codeOwnedCheck: () => void): void;
+export declare function validateOwnedAutonomousPersonalRecordGraphV4(graphValue: unknown, typedSyntaxWork: AutonomousPersonalTypedSyntaxWorkV1, codeOwnedCheck: () => void): GraphData | undefined;
+export declare function createIntegrityCheckedAutonomousPersonalClaimIndexV4(graphValue: unknown, typedSyntaxWork: AutonomousPersonalTypedSyntaxWorkV1, codeOwnedCheck: () => void): AutonomousPersonalClaimIndexV4;
+export declare function parseIntegrityCheckedAutonomousPersonalGraphV4(graphValue: unknown, typedSyntaxWork: AutonomousPersonalTypedSyntaxWorkV1, codeOwnedCheck: () => void): GraphData;
 export {};

package/dist/extraction/AutonomousPersonalQualifiedClaimV4.js

@@ -1,12 +1,17 @@
 "use strict";
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AutonomousPersonalClaimIndexV4Error = void 0;
+exports.AutonomousPersonalRecordIntegrityV4Error = exports.AutonomousPersonalClaimIndexV4Error = void 0;
 exports.createAutonomousPersonalClaimIndexV4 = createAutonomousPersonalClaimIndexV4;
 exports.getAutonomousPersonalClaimIndexGraphV4 = getAutonomousPersonalClaimIndexGraphV4;
+exports.getRegisteredAutonomousPersonalClaimIndexGraphV4 = getRegisteredAutonomousPersonalClaimIndexGraphV4;
 exports.getAutonomousPersonalClaimIndexCandidateRowsV4 = getAutonomousPersonalClaimIndexCandidateRowsV4;
 exports.inspectAutonomousPersonalClaimCreatorV4 = inspectAutonomousPersonalClaimCreatorV4;
 exports.qualifyAutonomousPersonalClaimCreatorV4 = qualifyAutonomousPersonalClaimCreatorV4;
+exports.assertAutonomousPersonalRecordIntegrityV4 = assertAutonomousPersonalRecordIntegrityV4;
+exports.validateOwnedAutonomousPersonalRecordGraphV4 = validateOwnedAutonomousPersonalRecordGraphV4;
+exports.createIntegrityCheckedAutonomousPersonalClaimIndexV4 = createIntegrityCheckedAutonomousPersonalClaimIndexV4;
+exports.parseIntegrityCheckedAutonomousPersonalGraphV4 = parseIntegrityCheckedAutonomousPersonalGraphV4;
 const node_perf_hooks_1 = require("node:perf_hooks");
 const node_util_1 = require("node:util");
 const AutomaticCapture_schema_1 = require("../schemas/AutomaticCapture.schema");
@@ -18,13 +23,16 @@ const AutonomousPersonalSourceScanV1_schema_1 = require("../schemas/AutonomousPe
 const AutonomousSourceGeometryV3_schema_1 = require("../schemas/AutonomousSourceGeometryV3.schema");
 const AutonomousPersonalOperationV4_schema_1 = require("../schemas/AutonomousPersonalOperationV4.schema");
 const AutonomousPersonalDescriptorV4_schema_1 = require("../schemas/AutonomousPersonalDescriptorV4.schema");
+const AutonomousPersonalRecordIntegrityV4_schema_1 = require("../schemas/AutonomousPersonalRecordIntegrityV4.schema");
 const ExtractionMetadata_schema_1 = require("../schemas/ExtractionMetadata.schema");
 const AutonomousPersonalRecordIdsV1_1 = require("../storage/AutonomousPersonalRecordIdsV1");
 const AutonomousPersonalClaimCandidateV1_1 = require("./AutonomousPersonalClaimCandidateV1");
 const AutonomousPersonalTypedSyntaxV1_1 = require("./AutonomousPersonalTypedSyntaxV1");
 const LosslessAutomaticCaptureGraph_1 = require("../storage/LosslessAutomaticCaptureGraph");
+const ImmutableGraphSnapshot_1 = require("../storage/ImmutableGraphSnapshot");
 const BoundedAutomaticCaptureJson_1 = require("../storage/BoundedAutomaticCaptureJson");
 const AutomaticIdentity_1 = require("../storage/AutomaticIdentity");
+const AutonomousPersonalExecutionScopeV1_1 = require("../storage/AutonomousPersonalExecutionScopeV1");
 const AutonomousPersonalTypedSyntaxV1_2 = require("./AutonomousPersonalTypedSyntaxV1");
 const EDGE_CLAIM_ATTRIBUTE = 'engram_claim_v1';
 const VALUE_LITERAL_ATTRIBUTE = 'engram_literal_v1';
@@ -78,7 +86,10 @@ function readWorkContext(value) {
             throw new AutonomousPersonalTypedSyntaxV1_2.AutonomousPersonalTypedSyntaxFailureV1('internal');
         }
         nativeAbortSignalAbortedGetter.call(signalProperty.value);
-        return { deadline: deadlineProperty.value, signal: signalProperty.value };
+        return {
+            deadline: deadlineProperty.value,
+            signal: signalProperty.value,
+        };
     }
     catch (error) {
         if (error instanceof AutonomousPersonalTypedSyntaxV1_2.AutonomousPersonalTypedSyntaxFailureV1)
@@ -221,13 +232,44 @@ function operationSourceId(operation) {
     return operation.identity.sourceId;
 }
 function createAutonomousPersonalClaimIndexV4(graphValue, typedSyntaxWork, codeOwnedCheck) {
-    var _a, _b;
+    var _a;
     const sticky = stickyCheck(codeOwnedCheck, typedSyntaxWork);
     const { check } = sticky;
+    const registered = getRegisteredAutonomousPersonalClaimIndexGraphV4(graphValue);
     try {
         check();
-        const graph = (0, LosslessAutomaticCaptureGraph_1.parseLosslessAutomaticCaptureGraph)(graphValue);
+        const graph = (_a = registered !== null && registered !== void 0 ? registered : (0, ImmutableGraphSnapshot_1.getOwnedImmutableGraphData)(graphValue)) !== null && _a !== void 0 ? _a : (0, LosslessAutomaticCaptureGraph_1.parseLosslessAutomaticCaptureGraph)(graphValue);
         check();
+        return indexOwnedParsedGraph(graph, sticky, true);
+    }
+    catch (error) {
+        mapClaimIndexFailure(error, sticky);
+    }
+}
+function indexParsedGraphV4(graph, typedSyntaxWork, codeOwnedCheck, freezeGraph) {
+    const sticky = stickyCheck(codeOwnedCheck, typedSyntaxWork);
+    try {
+        sticky.check();
+        sticky.check();
+        return indexOwnedParsedGraph(graph, sticky, freezeGraph);
+    }
+    catch (error) {
+        mapClaimIndexFailure(error, sticky);
+    }
+}
+function mapClaimIndexFailure(error, sticky) {
+    sticky.rethrowFailure();
+    if (error instanceof AutonomousPersonalTypedSyntaxV1_2.AutonomousPersonalTypedSyntaxFailureV1)
+        throw error;
+    if (error instanceof BoundedAutomaticCaptureJson_1.BoundedAutomaticCaptureJsonError && error.reason !== 'invalid_json') {
+        snapshotFailure('snapshot_capacity');
+    }
+    snapshotFailure('invalid_snapshot');
+}
+function indexOwnedParsedGraph(graph, sticky, freezeGraph) {
+    var _a, _b;
+    const { check } = sticky;
+    {
         ensureGlobalIdsUnique(graph, check);
         const entities = indexRows(graph.entities, check);
         const edges = indexRows(graph.edges, check);
@@ -244,7 +286,8 @@ function createAutonomousPersonalClaimIndexV4(graphValue, typedSyntaxWork, codeO
         for (const rows of operationsBySource.values())
             Object.freeze(rows);
         const bindingIndex = indexBindings(graph, check);
-        freeze(graph, check);
+        if (freezeGraph)
+            freeze(graph, check);
         const root = {
             graph,
             entities,
@@ -263,15 +306,6 @@ function createAutonomousPersonalClaimIndexV4(graphValue, typedSyntaxWork, codeO
         indices.set(token, root);
         return token;
     }
-    catch (error) {
-        sticky.rethrowFailure();
-        if (error instanceof AutonomousPersonalTypedSyntaxV1_2.AutonomousPersonalTypedSyntaxFailureV1)
-            throw error;
-        if (error instanceof BoundedAutomaticCaptureJson_1.BoundedAutomaticCaptureJsonError && error.reason !== 'invalid_json') {
-            snapshotFailure('snapshot_capacity');
-        }
-        snapshotFailure('invalid_snapshot');
-    }
 }
 function rootFor(index) {
     if (index === null || typeof index !== 'object')
@@ -290,6 +324,11 @@ function getAutonomousPersonalClaimIndexGraphV4(index) {
     root.check();
     return graph;
 }
+function getRegisteredAutonomousPersonalClaimIndexGraphV4(value) {
+    if (value === null || typeof value !== 'object' || !indices.has(value))
+        return undefined;
+    return getAutonomousPersonalClaimIndexGraphV4(value);
+}
 function getAutonomousPersonalClaimIndexCandidateRowsV4(indexValue, edgeIdValue) {
     var _a, _b, _c, _d, _e;
     const root = rootFor(indexValue);
@@ -393,7 +432,10 @@ function invalid(root, reason) {
     return resultData(root, { status: 'invalid', reason });
 }
 function uncommitted(root) {
-    return resultData(root, { status: 'uncommitted', reason: 'capture_not_committed' });
+    return resultData(root, {
+        status: 'uncommitted',
+        reason: 'capture_not_committed',
+    });
 }
 function capacity(root) {
     return resultData(root, { status: 'capacity', reason: 'proof_capacity' });
@@ -431,7 +473,10 @@ function getSourceEvidence(root, source, descriptor) {
     }
     root.check();
     try {
-        const stored = (0, AutonomousPersonalSourceV4_schema_1.reconstructAutonomousPersonalStoredSourceIdentityV4)({ source, descriptor });
+        const stored = (0, AutonomousPersonalSourceV4_schema_1.reconstructAutonomousPersonalStoredSourceIdentityV4)({
+            source,
+            descriptor,
+        });
         if (!AutonomousPersonalSourceV4_schema_1.AutonomousPersonalStoredSourceIdentityV4OwnedDataSchema.safeParse(stored).success) {
             root.check();
             root.sourceEvidence.set(source.uuid, { kind: 'invalid' });
@@ -843,7 +888,10 @@ function qualifyAutonomousPersonalClaimCreatorV4(indexValue, requestValue) {
     if (request.storeHash !== proof.storeHash)
         return resultData(root, { status: 'inactive', reason: 'store_mismatch' });
     if (request.namespace !== proof.namespace)
-        return resultData(root, { status: 'inactive', reason: 'namespace_mismatch' });
+        return resultData(root, {
+            status: 'inactive',
+            reason: 'namespace_mismatch',
+        });
     const edgeRows = (_a = root.edges.get(proof.claimId)) !== null && _a !== void 0 ? _a : [];
     const sourceRows = (_b = root.episodes.get(proof.sourceId)) !== null && _b !== void 0 ? _b : [];
     const opRows = (_c = root.operationsById.get(proof.operationId)) !== null && _c !== void 0 ? _c : [];
@@ -863,7 +911,10 @@ function qualifyAutonomousPersonalClaimCreatorV4(indexValue, requestValue) {
         actorReference: operation.data.identity.actorReference,
         binding: operation.data.identity.binding,
     })) {
-        return resultData(root, { status: 'inactive', reason: 'authority_inactive' });
+        return resultData(root, {
+            status: 'inactive',
+            reason: 'authority_inactive',
+        });
     }
     if (source.review_status !== 'accepted' ||
         source.trust_level !== operation.data.descriptor.requestedTrustLevel) {
@@ -892,4 +943,437 @@ function qualifyAutonomousPersonalClaimCreatorV4(indexValue, requestValue) {
     root.check();
     return resultData(root, { status: 'qualified', proof });
 }
+const CLAIM_ATTRIBUTE = 'engram_claim_v1';
+const VALUE_MARKER_ATTRIBUTE = 'engram_literal_v1';
+const PERSONAL_VALUE_TYPE = 'autonomous_personal_value';
+const PERSONAL_FAMILY = 'autonomous-personal-v1';
+class AutonomousPersonalRecordIntegrityV4Error extends Error {
+    constructor(reason) {
+        const parsedReason = AutonomousPersonalRecordIntegrityV4_schema_1.AutonomousPersonalRecordIntegrityV4FailureReasonSchema.safeParse(reason);
+        super('Engram autonomous personal record integrity failed');
+        this.name = 'AutonomousPersonalRecordIntegrityV4Error';
+        this.reason = parsedReason.success ? parsedReason.data : 'invalid_snapshot';
+        Object.freeze(this);
+    }
+}
+exports.AutonomousPersonalRecordIntegrityV4Error = AutonomousPersonalRecordIntegrityV4Error;
+function fail(reason) {
+    throw new AutonomousPersonalRecordIntegrityV4Error(reason);
+}
+function stickyTrustedCheck(callback) {
+    let failed = false;
+    let failure;
+    const check = () => {
+        if (failed)
+            throw failure;
+        try {
+            callback();
+        }
+        catch (error) {
+            failed = true;
+            failure = error;
+            throw error;
+        }
+    };
+    return {
+        check,
+        rethrowFailure: () => {
+            if (failed)
+                throw failure;
+        },
+    };
+}
+function stickyWorkCheck(work, trusted) {
+    const supplied = readWorkContext(work);
+    const abortedGetter = nativeAbortSignalAbortedGetter;
+    if (abortedGetter === undefined)
+        throw new AutonomousPersonalTypedSyntaxV1_2.AutonomousPersonalTypedSyntaxFailureV1('internal');
+    let failed = false;
+    let failure;
+    const latch = (error) => {
+        if (!failed) {
+            failed = true;
+            failure = error;
+        }
+        throw failure;
+    };
+    const checkWork = () => {
+        try {
+            if (abortedGetter.call(supplied.signal)) {
+                throw new AutonomousPersonalTypedSyntaxV1_2.AutonomousPersonalTypedSyntaxFailureV1('cancelled');
+            }
+            const now = node_perf_hooks_1.performance.now();
+            if (!Number.isFinite(now))
+                throw new AutonomousPersonalTypedSyntaxV1_2.AutonomousPersonalTypedSyntaxFailureV1('internal');
+            if (now >= supplied.deadline)
+                throw new AutonomousPersonalTypedSyntaxV1_2.AutonomousPersonalTypedSyntaxFailureV1('deadline');
+        }
+        catch (error) {
+            if (error instanceof AutonomousPersonalTypedSyntaxV1_2.AutonomousPersonalTypedSyntaxFailureV1)
+                throw error;
+            throw new AutonomousPersonalTypedSyntaxV1_2.AutonomousPersonalTypedSyntaxFailureV1('internal');
+        }
+    };
+    const check = () => {
+        if (failed)
+            throw failure;
+        try {
+            checkWork();
+            trusted.check();
+            checkWork();
+        }
+        catch (error) {
+            latch(error);
+        }
+    };
+    return {
+        check,
+        rethrowFailure: () => {
+            if (failed)
+                throw failure;
+            trusted.rethrowFailure();
+        },
+    };
+}
+function isFamilyFourTag(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const record = value;
+    return ((typeof record.version === 'number' && record.version >= 3) || record.family === PERSONAL_FAMILY);
+}
+function collectFootprints(graph, check) {
+    var _a, _b;
+    const edgeIds = new Set();
+    const valueIds = new Set();
+    const positiveOccurrences = [];
+    check();
+    for (const edge of graph.edges) {
+        check();
+        if (isFamilyFourTag(edge.attributes[CLAIM_ATTRIBUTE]))
+            edgeIds.add(edge.uuid);
+    }
+    check();
+    for (const entity of graph.entities) {
+        check();
+        if (isFamilyFourTag(entity.attributes[VALUE_MARKER_ATTRIBUTE]) ||
+            entity.entity_type === PERSONAL_VALUE_TYPE) {
+            valueIds.add(entity.uuid);
+        }
+    }
+    check();
+    for (const storedOperation of (_b = (_a = graph.automatic_operations_v1) === null || _a === void 0 ? void 0 : _a.operations) !== null && _b !== void 0 ? _b : []) {
+        check();
+        if (storedOperation.version !== 4 || storedOperation.state !== 'committed')
+            continue;
+        const operation = storedOperation;
+        const receipt = operation.terminalReceipt;
+        if (receipt.kind !== 'human_autonomous_capture_committed')
+            continue;
+        if (receipt.selection.kind !== 'occurrences')
+            continue;
+        for (const item of receipt.selection.items) {
+            check();
+            if (item.effect === 'created' || item.effect === 'reference') {
+                positiveOccurrences.push({ operation, item });
+            }
+        }
+    }
+    check();
+    return { edgeIds, valueIds, positiveOccurrences };
+}
+function mapOwnershipFailure(error) {
+    if (error instanceof BoundedAutomaticCaptureJson_1.BoundedAutomaticCaptureJsonError && error.reason !== 'invalid_json') {
+        fail('snapshot_capacity');
+    }
+    fail('invalid_snapshot');
+}
+function mapIndexFailure(error) {
+    if (error instanceof AutonomousPersonalClaimIndexV4Error) {
+        fail(error.reason === 'snapshot_capacity' ? 'snapshot_capacity' : 'invalid_snapshot');
+    }
+    if (error instanceof BoundedAutomaticCaptureJson_1.BoundedAutomaticCaptureJsonError && error.reason !== 'invalid_json') {
+        fail('snapshot_capacity');
+    }
+    if (error instanceof AutonomousPersonalTypedSyntaxV1_2.AutonomousPersonalTypedSyntaxFailureV1)
+        throw error;
+    fail('inspection_incomplete');
+}
+function equalData(left, right) {
+    return (0, AutomaticCapture_schema_1.canonicalAutomaticCaptureV2)(left) === (0, AutomaticCapture_schema_1.canonicalAutomaticCaptureV2)(right);
+}
+function required(value, reason, check) {
+    if (value === null || value === undefined) {
+        check();
+        fail(reason);
+    }
+    return value;
+}
+function inspectFailureReason(result) {
+    if (result.status === 'capacity') {
+        return result.reason === 'snapshot_capacity' ? 'snapshot_capacity' : 'inspection_incomplete';
+    }
+    if (result.status === 'uncommitted')
+        return 'orphan_record';
+    if (result.status !== 'invalid')
+        return 'inspection_incomplete';
+    if (result.reason === 'missing_record')
+        return 'orphan_record';
+    if (result.reason === 'invalid_operation' ||
+        result.reason === 'invalid_creator' ||
+        result.reason === 'unsupported_generation' ||
+        result.reason === 'ambiguous_record') {
+        return 'invalid_creator';
+    }
+    return 'invalid_pair';
+}
+function validatePositiveOccurrences(occurrences, proofs, check) {
+    var _a;
+    const creatorsByClaim = new Map();
+    for (const occurrence of occurrences) {
+        check();
+        const claimId = required(occurrence.item.claimId, 'invalid_creator', check);
+        if (occurrence.item.effect !== 'created')
+            continue;
+        const rows = (_a = creatorsByClaim.get(claimId)) !== null && _a !== void 0 ? _a : [];
+        rows.push(occurrence);
+        creatorsByClaim.set(claimId, rows);
+    }
+    check();
+    for (const [claimId, creators] of creatorsByClaim) {
+        check();
+        if (creators.length !== 1) {
+            check();
+            fail('invalid_creator');
+        }
+        const proof = required(proofs.get(claimId), 'orphan_record', check);
+        const creator = creators[0];
+        const receipt = creator.operation.terminalReceipt;
+        const item = creator.item;
+        if (proof.operationId !== creator.operation.operationId ||
+            proof.operationId !== receipt.operationId ||
+            proof.sourceId !== creator.operation.identity.sourceId ||
+            proof.sourceId !== receipt.sourceId ||
+            proof.claimId !== claimId ||
+            proof.kind !== item.kind ||
+            proof.evidenceHash !== item.evidenceHash ||
+            proof.meaningHash !== item.meaningHash ||
+            !equalData(proof.dependencies, item.dependencies)) {
+            check();
+            fail('invalid_creator');
+        }
+    }
+    check();
+    for (const occurrence of occurrences) {
+        check();
+        const item = occurrence.item;
+        const claimId = required(item.claimId, 'invalid_creator', check);
+        const proof = required(proofs.get(claimId), 'orphan_record', check);
+        const identityMatches = proof.storeHash === occurrence.operation.identity.storeHash &&
+            proof.namespace === occurrence.operation.identity.namespace &&
+            proof.subjectId === occurrence.operation.identity.binding.subjectId;
+        if (!identityMatches) {
+            check();
+            fail(item.effect === 'reference' ? 'invalid_pair' : 'invalid_creator');
+        }
+        if (proof.claimId !== claimId ||
+            proof.kind !== item.kind ||
+            proof.meaningHash !== item.meaningHash) {
+            check();
+            fail(item.effect === 'created' ? 'invalid_creator' : 'invalid_pair');
+        }
+    }
+    check();
+}
+function validateFootprints(graph, footprints, index, check) {
+    var _a;
+    const edgeRowsById = new Map();
+    check();
+    for (const edge of graph.edges) {
+        check();
+        edgeRowsById.set(edge.uuid, edge);
+    }
+    check();
+    const candidateEdgeIds = new Set(footprints.edgeIds);
+    const creatorCounts = new Map();
+    for (const occurrence of footprints.positiveOccurrences) {
+        check();
+        const claimId = required(occurrence.item.claimId, 'invalid_creator', check);
+        candidateEdgeIds.add(claimId);
+        if (occurrence.item.effect === 'created') {
+            creatorCounts.set(claimId, ((_a = creatorCounts.get(claimId)) !== null && _a !== void 0 ? _a : 0) + 1);
+        }
+    }
+    check();
+    for (const count of creatorCounts.values()) {
+        check();
+        if (count !== 1) {
+            check();
+            fail('invalid_creator');
+        }
+    }
+    check();
+    const proofs = new Map();
+    for (const claimId of candidateEdgeIds) {
+        check();
+        if (!edgeRowsById.has(claimId)) {
+            check();
+            fail('orphan_record');
+        }
+        let result;
+        try {
+            result = inspectAutonomousPersonalClaimCreatorV4(index, claimId);
+        }
+        catch (error) {
+            if (error instanceof AutonomousPersonalTypedSyntaxV1_2.AutonomousPersonalTypedSyntaxFailureV1)
+                throw error;
+            check();
+            fail('inspection_incomplete');
+        }
+        check();
+        if (result.status !== 'structural') {
+            check();
+            fail(inspectFailureReason(result));
+        }
+        proofs.set(claimId, result.proof);
+    }
+    check();
+    for (const edgeId of footprints.edgeIds) {
+        check();
+        const proof = proofs.get(edgeId);
+        if (!proof || proof.claimId !== edgeId) {
+            check();
+            fail('orphan_record');
+        }
+    }
+    check();
+    for (const valueId of footprints.valueIds) {
+        check();
+        let matchingProofCount = 0;
+        for (const proof of proofs.values()) {
+            check();
+            if (proof.valueId === valueId)
+                matchingProofCount += 1;
+        }
+        if (matchingProofCount === 0) {
+            check();
+            fail('orphan_record');
+        }
+        if (matchingProofCount !== 1) {
+            check();
+            fail('invalid_pair');
+        }
+    }
+    check();
+    validatePositiveOccurrences(footprints.positiveOccurrences, proofs, check);
+    check();
+}
+function checkAutonomousPersonalRecordIntegrityV4(graphValue, typedSyntaxWork, codeOwnedCheck, requireIndex) {
+    return checkOwnedAutonomousPersonalRecordIntegrityV4(graphValue, typedSyntaxWork, codeOwnedCheck, requireIndex).index;
+}
+function checkOwnedAutonomousPersonalRecordIntegrityV4(graphValue, typedSyntaxWork, codeOwnedCheck, requireIndex) {
+    var _a;
+    const trusted = stickyTrustedCheck(codeOwnedCheck);
+    trusted.check();
+    const registered = getRegisteredAutonomousPersonalClaimIndexGraphV4(graphValue);
+    if (registered) {
+        trusted.check();
+        return {
+            index: checkParsedAutonomousPersonalRecordIntegrityV4(registered, typedSyntaxWork, trusted, requireIndex),
+        };
+    }
+    let graph;
+    let ownershipFailure;
+    try {
+        graph =
+            (_a = (0, ImmutableGraphSnapshot_1.getOwnedImmutableGraphData)(graphValue)) !== null && _a !== void 0 ? _a : (0, LosslessAutomaticCaptureGraph_1.parseLosslessAutomaticCaptureGraph)(graphValue);
+    }
+    catch (error) {
+        ownershipFailure = error;
+    }
+    trusted.check();
+    if (ownershipFailure !== undefined) {
+        trusted.rethrowFailure();
+        mapOwnershipFailure(ownershipFailure);
+    }
+    if (!graph)
+        fail('invalid_snapshot');
+    const index = checkParsedAutonomousPersonalRecordIntegrityV4(graph, typedSyntaxWork, trusted, requireIndex);
+    return requireIndex ? { index } : { index, owned: graph };
+}
+function checkParsedAutonomousPersonalRecordIntegrityV4(graph, typedSyntaxWork, trusted, requireIndex) {
+    const footprints = collectFootprints(graph, trusted.check);
+    trusted.check();
+    if (footprints.edgeIds.size === 0 &&
+        footprints.valueIds.size === 0 &&
+        footprints.positiveOccurrences.length === 0) {
+        trusted.check();
+        if (!requireIndex)
+            return undefined;
+    }
+    const workCheck = stickyWorkCheck(typedSyntaxWork, trusted);
+    let index;
+    let indexedGraph = graph;
+    try {
+        workCheck.check();
+        index = indexParsedGraphV4(graph, typedSyntaxWork, workCheck.check, requireIndex);
+        workCheck.check();
+        if (requireIndex) {
+            indexedGraph = getAutonomousPersonalClaimIndexGraphV4(index);
+            workCheck.check();
+        }
+    }
+    catch (error) {
+        workCheck.rethrowFailure();
+        if (error instanceof AutonomousPersonalTypedSyntaxV1_2.AutonomousPersonalTypedSyntaxFailureV1)
+            throw error;
+        mapIndexFailure(error);
+    }
+    try {
+        validateFootprints(requireIndex ? indexedGraph : graph, footprints, index, workCheck.check);
+        workCheck.check();
+    }
+    catch (error) {
+        workCheck.rethrowFailure();
+        if (error instanceof AutonomousPersonalTypedSyntaxV1_2.AutonomousPersonalTypedSyntaxFailureV1)
+            throw error;
+        if (error instanceof AutonomousPersonalRecordIntegrityV4Error)
+            throw error;
+        mapIndexFailure(error);
+    }
+    workCheck.check();
+    return requireIndex ? index : undefined;
+}
+function assertAutonomousPersonalRecordIntegrityV4(graphValue, typedSyntaxWork, codeOwnedCheck) {
+    checkAutonomousPersonalRecordIntegrityV4(graphValue, typedSyntaxWork, codeOwnedCheck, false);
+}
+function validateOwnedAutonomousPersonalRecordGraphV4(graphValue, typedSyntaxWork, codeOwnedCheck) {
+    return checkOwnedAutonomousPersonalRecordIntegrityV4(graphValue, typedSyntaxWork, codeOwnedCheck, false).owned;
+}
+function createIntegrityCheckedAutonomousPersonalClaimIndexV4(graphValue, typedSyntaxWork, codeOwnedCheck) {
+    const index = checkAutonomousPersonalRecordIntegrityV4(graphValue, typedSyntaxWork, codeOwnedCheck, true);
+    if (!index)
+        fail('invalid_snapshot');
+    return index;
+}
+function meteredV4(operation, work = (0, AutonomousPersonalExecutionScopeV1_1.currentAutonomousPersonalExecutionScopeWorkV1)()) {
+    return work === undefined
+        ? operation()
+        : (0, AutonomousPersonalExecutionScopeV1_1.runCurrentAutonomousPersonalExecutionScopeSyntaxSpanV1)(work, operation);
+}
+function parseIntegrityCheckedAutonomousPersonalGraphV4(graphValue, typedSyntaxWork, codeOwnedCheck) {
+    const graph = meteredV4(() => (0, LosslessAutomaticCaptureGraph_1.parseLosslessAutomaticCaptureGraph)(graphValue));
+    meteredV4(() => {
+        codeOwnedCheck();
+        (0, AutomaticIdentity_1.assertAutomaticLedgerSourceIntegrity)(graph);
+        codeOwnedCheck();
+        meteredV4(() => {
+            const trusted = stickyTrustedCheck(codeOwnedCheck);
+            trusted.check();
+            trusted.check();
+            checkParsedAutonomousPersonalRecordIntegrityV4(graph, typedSyntaxWork, trusted, false);
+        });
+        codeOwnedCheck();
+    }, typedSyntaxWork);
+    return graph;
+}
 //# sourceMappingURL=AutonomousPersonalQualifiedClaimV4.js.map