agentfootprint 9.59.1 → 9.60.0

package/dist/esm/events/registry.d.ts

@@ -16,7 +16,7 @@
  * major bump. See agentfootprint_v2_detailed_design.md for rules.
  */
 import type { AgentfootprintEventEnvelope } from './types.js';
-import type { AgentHandoffPayload, AgentIterationEndPayload, AgentIterationStartPayload, AgentBudgetExhaustedPayload, AgentRouteDecidedPayload, AgentTurnEndPayload, AgentTurnStartPayload, CompositionEnterPayload, CompositionExitPayload, ConditionalRouteDecidedPayload, ContextBudgetPressurePayload, ContextEvaluatedPayload, ContextEvictedPayload, ContextInjectedPayload, ContextSlotComposedPayload, CostLimitHitPayload, CostTickPayload, EmbeddingGeneratedPayload, ErrorCircuitChangedPayload, ErrorFatalPayload, ErrorRecoveredPayload, ErrorRetriedPayload, EvalScorePayload, EvalThresholdCrossedPayload, AgentOutputSchemaValidationFailedPayload, AgentOutputContractUnmetPayload, AgentOutputSchemaRetryPayload, AgentEvidenceCheckedPayload, AgentRunConfiguredPayload, AgentThinkingParseFailedPayload, StreamThinkingDeltaPayload, StreamThinkingEndPayload, FallbackTriggeredPayload, LLMEndPayload, LLMStartPayload, LLMTokenPayload, LoopIterationExitPayload, LoopIterationStartPayload, MemoryAttachedPayload, MemoryDetachedPayload, MemoryRetrievedPayload, MemoryStrategyAppliedPayload, MemoryWrittenPayload, ParallelBranchCompletePayload, ParallelForkStartPayload, ParallelMergeEndPayload, PauseRequestPayload, PauseResumePayload, CheckInRequestPayload, CheckInDecisionPayload, PermissionCheckPayload, PermissionGateClosedPayload, PermissionHaltPayload, PermissionGateOpenedPayload, CredentialRequestedPayload, CredentialAcquiredPayload, CredentialAuthorizationRequiredPayload, CredentialFailedPayload, ReliabilityFailFastPayload, ReliabilityRetriedPayload, ReliabilityRecoveredPayload, ResilienceOutputFallbackTriggeredPayload, ResilienceOutputCannedUsedPayload, RiskFlaggedPayload, SkillActivatedPayload, SkillDeactivatedPayload, SkillEscalatedPayload, SkillGraphDeclaredPayload, SkillRejectedPayload, SkillRerouteSupersededPayload, SkillRouteConflictPayload, SkillStepAdvancedPayload, SkillStepSkippedPayload, SkillStepsUnfinishedPayload, SkillTurnRoutedPayload, ToolAbsentPayload, ToolCoverageDeclaredPayload, ToolSemanticsDeclaredPayload, ToolsCodeRunPayload, ToolEffectPayload, ToolRepeatedCallPayload, ToolResultRefusedPayload, ToolEndPayload, ToolsActivatedPayload, ToolsDeactivatedPayload, ToolsDiscoveryStartedPayload, ToolsDiscoveryCompletedPayload, ToolsDiscoveryFailedPayload, ToolsShadowedPayload, ToolsSessionStartedPayload, ToolsSessionReusedPayload, ToolsSessionClosedPayload, ToolsSessionCloseFailedPayload, ToolsOfferedPayload, ToolProgressPayload, ToolStartPayload, ValidationArgsInvalidPayload, MiddlewareDecisionPayload, ArtifactMintedPayload, ArtifactResolvedPayload, ArtifactExpiredPayload, ArtifactRefusedPayload, ArtifactPresentedPayload, MapEngagedPayload, MapParkedPayload } from './payloads.js';
+import type { AgentHandoffPayload, AgentIterationEndPayload, AgentIterationStartPayload, AgentBudgetExhaustedPayload, AgentRouteDecidedPayload, AgentTurnEndPayload, AgentTurnStartPayload, CompositionEnterPayload, CompositionExitPayload, ConditionalRouteDecidedPayload, ContextBudgetPressurePayload, ContextEvaluatedPayload, ContextEvictedPayload, ContextInjectedPayload, ContextSlotComposedPayload, CostLimitHitPayload, CostTickPayload, EmbeddingGeneratedPayload, ErrorCircuitChangedPayload, ErrorFatalPayload, ErrorRecoveredPayload, ErrorRetriedPayload, EvalScorePayload, EvalThresholdCrossedPayload, AgentOutputSchemaValidationFailedPayload, AgentOutputContractUnmetPayload, AgentOutputSchemaRetryPayload, AgentEvidenceCheckedPayload, AgentRunConfiguredPayload, AgentThinkingParseFailedPayload, StreamThinkingDeltaPayload, StreamThinkingEndPayload, FallbackTriggeredPayload, LLMEndPayload, LLMStartPayload, LLMTokenPayload, LoopIterationExitPayload, LoopIterationStartPayload, MemoryAttachedPayload, MemoryDetachedPayload, MemoryRetrievedPayload, MemoryStrategyAppliedPayload, MemoryWrittenPayload, ParallelBranchCompletePayload, ParallelForkStartPayload, ParallelMergeEndPayload, PauseRequestPayload, PauseResumePayload, CheckInRequestPayload, CheckInDecisionPayload, PermissionCheckPayload, PermissionGateClosedPayload, PermissionHaltPayload, PermissionGateOpenedPayload, CredentialRequestedPayload, CredentialAcquiredPayload, CredentialAuthorizationRequiredPayload, CredentialFailedPayload, ReliabilityFailFastPayload, ReliabilityRetriedPayload, ReliabilityRecoveredPayload, ResilienceOutputFallbackTriggeredPayload, ResilienceOutputCannedUsedPayload, RiskFlaggedPayload, SkillActivatedPayload, SkillDeactivatedPayload, SkillEscalatedPayload, SkillGraphDeclaredPayload, SkillRejectedPayload, SkillRerouteSupersededPayload, SkillRouteConflictPayload, SkillStepAdvancedPayload, SkillStepSkippedPayload, SkillStepsUnfinishedPayload, SkillTurnRoutedPayload, ToolAbsentPayload, ToolCoverageDeclaredPayload, ToolSemanticsDeclaredPayload, ToolsCodeRunPayload, ToolEffectPayload, ToolRepeatedCallPayload, ToolResultRefusedPayload, ToolEndPayload, ToolsActivatedPayload, ToolsDeactivatedPayload, ToolsDiscoveryStartedPayload, ToolsDiscoveryCompletedPayload, ToolsDiscoveryFailedPayload, ToolsShadowedPayload, ToolsSessionStartedPayload, ToolsSessionReusedPayload, ToolsSessionClosedPayload, ToolsSessionCloseFailedPayload, ToolsOfferedPayload, ToolProgressPayload, ToolStartPayload, ValidationArgsInvalidPayload, MiddlewareDecisionPayload, ArtifactMintedPayload, ArtifactResolvedPayload, ArtifactExpiredPayload, ArtifactRefusedPayload, ArtifactPresentedPayload, MapEngagedPayload, MapParkedPayload, IntegrityContextErrorPayload, IntegrityDispositionPayload } from './payloads.js';
 export declare const EVENT_NAMES: {
     readonly composition: {
         readonly enter: "agentfootprint.composition.enter";
@@ -104,6 +104,10 @@ export declare const EVENT_NAMES: {
         readonly engaged: "agentfootprint.map.engaged";
         readonly parked: "agentfootprint.map.parked";
     };
+    readonly integrity: {
+        readonly contextError: "agentfootprint.integrity.context_error";
+        readonly disposition: "agentfootprint.integrity.disposition";
+    };
     readonly validation: {
         readonly argsInvalid: "agentfootprint.validation.args_invalid";
     };
@@ -276,6 +280,8 @@ export interface AgentfootprintEventMap {
     'agentfootprint.artifacts.presented': AgentfootprintEventEnvelope<'agentfootprint.artifacts.presented', ArtifactPresentedPayload>;
     'agentfootprint.map.engaged': AgentfootprintEventEnvelope<'agentfootprint.map.engaged', MapEngagedPayload>;
     'agentfootprint.map.parked': AgentfootprintEventEnvelope<'agentfootprint.map.parked', MapParkedPayload>;
+    'agentfootprint.integrity.context_error': AgentfootprintEventEnvelope<'agentfootprint.integrity.context_error', IntegrityContextErrorPayload>;
+    'agentfootprint.integrity.disposition': AgentfootprintEventEnvelope<'agentfootprint.integrity.disposition', IntegrityDispositionPayload>;
 }
 /** Union of every typed event. Consumers use this for exhaustive `switch`. */
 export type AgentfootprintEvent = AgentfootprintEventMap[keyof AgentfootprintEventMap];

package/dist/esm/events/registry.js

@@ -105,6 +105,10 @@ export const EVENT_NAMES = {
         engaged: 'agentfootprint.map.engaged',
         parked: 'agentfootprint.map.parked',
     },
+    integrity: {
+        contextError: 'agentfootprint.integrity.context_error',
+        disposition: 'agentfootprint.integrity.disposition',
+    },
     validation: {
         argsInvalid: 'agentfootprint.validation.args_invalid',
     },
@@ -281,5 +285,7 @@ export const ALL_EVENT_TYPES = [
     'agentfootprint.artifacts.presented',
     'agentfootprint.map.engaged',
     'agentfootprint.map.parked',
+    'agentfootprint.integrity.context_error',
+    'agentfootprint.integrity.disposition',
 ];
 //# sourceMappingURL=registry.js.map

package/dist/esm/events/registry.js.map

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

package/dist/esm/integrity/assertion/conflicts.d.ts

@@ -0,0 +1,35 @@
+/**
+ * conflictsOf — the exclusion comparison, pure.
+ *
+ * Pattern: pure function over a finite assertion set. No I/O, no store.
+ * Role:    the algebra's first comparison: two `asserted` (never quoted)
+ *          assertions on one single-valued `(subject, predicate, epoch)`
+ *          key with different comparable values cannot both be true.
+ *
+ * What it deliberately does NOT do:
+ *   - fire across strata (history is quotation);
+ *   - compare unknowns (honest absence — an unknown neither corroborates
+ *     nor contradicts);
+ *   - fire on multi-valued predicates (the declared exception);
+ *   - infer subject identity (no stamp, no comparison);
+ *   - resolve anything — it names pairs; the caller files findings.
+ *
+ * Values compare by structural equality over their comparable face (a
+ * known `Claim` compares by its value), via JSON with sorted keys — the
+ * same determinism bar the house holds serialization to elsewhere.
+ */
+import { type Assertion } from './types.js';
+/** One exclusion: the two-or-more assertions that cannot all be true. */
+export interface Conflict {
+    readonly key: string;
+    /** Every distinct-valued assertion on the key, in input order. */
+    readonly assertions: readonly Assertion[];
+}
+/**
+ * Find every single-valued key carrying two or more distinct values.
+ *
+ * @param assertions the finite set under comparison (one payload, or one
+ *                   write-delta joined with the standing set for a subject)
+ * @param multiValued predicates exempt from single-valuedness, declared
+ */
+export declare function conflictsOf(assertions: readonly Assertion[], multiValued?: ReadonlySet<string>): readonly Conflict[];

package/dist/esm/integrity/assertion/conflicts.js

@@ -0,0 +1,74 @@
+/**
+ * conflictsOf — the exclusion comparison, pure.
+ *
+ * Pattern: pure function over a finite assertion set. No I/O, no store.
+ * Role:    the algebra's first comparison: two `asserted` (never quoted)
+ *          assertions on one single-valued `(subject, predicate, epoch)`
+ *          key with different comparable values cannot both be true.
+ *
+ * What it deliberately does NOT do:
+ *   - fire across strata (history is quotation);
+ *   - compare unknowns (honest absence — an unknown neither corroborates
+ *     nor contradicts);
+ *   - fire on multi-valued predicates (the declared exception);
+ *   - infer subject identity (no stamp, no comparison);
+ *   - resolve anything — it names pairs; the caller files findings.
+ *
+ * Values compare by structural equality over their comparable face (a
+ * known `Claim` compares by its value), via JSON with sorted keys — the
+ * same determinism bar the house holds serialization to elsewhere.
+ */
+import { assertionKey, comparableValueOf, participates } from './types.js';
+/** Deterministic structural rendering — sorted keys, no ambient state. */
+function renderValue(value) {
+    const face = comparableValueOf(value);
+    return JSON.stringify(face, (_k, v) => {
+        if (v !== null && typeof v === 'object' && !Array.isArray(v)) {
+            const sorted = {};
+            for (const key of Object.keys(v).sort()) {
+                sorted[key] = v[key];
+            }
+            return sorted;
+        }
+        return v;
+    });
+}
+/**
+ * Find every single-valued key carrying two or more distinct values.
+ *
+ * @param assertions the finite set under comparison (one payload, or one
+ *                   write-delta joined with the standing set for a subject)
+ * @param multiValued predicates exempt from single-valuedness, declared
+ */
+export function conflictsOf(assertions, multiValued = new Set()) {
+    const byKey = new Map();
+    for (const a of assertions) {
+        if (a.stratum !== 'asserted')
+            continue; // history is quotation
+        if (multiValued.has(a.predicate))
+            continue; // the declared exception
+        if (!participates(a.value))
+            continue; // unknowns never compare
+        const key = assertionKey(a);
+        let entry = byKey.get(key);
+        if (entry === undefined) {
+            entry = { byValue: new Map(), order: [] };
+            byKey.set(key, entry);
+        }
+        const rendered = renderValue(a.value);
+        const bucket = entry.byValue.get(rendered);
+        if (bucket === undefined)
+            entry.byValue.set(rendered, [a]);
+        else
+            bucket.push(a);
+        entry.order.push(a);
+    }
+    const conflicts = [];
+    for (const [key, entry] of byKey) {
+        if (entry.byValue.size < 2)
+            continue;
+        conflicts.push({ key, assertions: entry.order });
+    }
+    return conflicts;
+}
+//# sourceMappingURL=conflicts.js.map

package/dist/esm/integrity/assertion/conflicts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conflicts.js","sourceRoot":"","sources":["../../../../src/integrity/assertion/conflicts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,YAAY,EAAkB,MAAM,YAAY,CAAC;AAS3F,0EAA0E;AAC1E,SAAS,WAAW,CAAC,KAAc;IACjC,MAAM,IAAI,GAAG,iBAAiB,CAAC,KAAK,CAAC,CAAC;IACtC,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,CAAU,EAAE,EAAE;QAC7C,IAAI,CAAC,KAAK,IAAI,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC;YAC7D,MAAM,MAAM,GAA4B,EAAE,CAAC;YAC3C,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,CAAW,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC;gBAClD,MAAM,CAAC,GAAG,CAAC,GAAI,CAA6B,CAAC,GAAG,CAAC,CAAC;YACpD,CAAC;YACD,OAAO,MAAM,CAAC;QAChB,CAAC;QACD,OAAO,CAAC,CAAC;IACX,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,WAAW,CACzB,UAAgC,EAChC,cAAmC,IAAI,GAAG,EAAE;IAE5C,MAAM,KAAK,GAAG,IAAI,GAAG,EAAqE,CAAC;IAE3F,KAAK,MAAM,CAAC,IAAI,UAAU,EAAE,CAAC;QAC3B,IAAI,CAAC,CAAC,OAAO,KAAK,UAAU;YAAE,SAAS,CAAC,uBAAuB;QAC/D,IAAI,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC;YAAE,SAAS,CAAC,yBAAyB;QACrE,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC;YAAE,SAAS,CAAC,yBAAyB;QAC/D,MAAM,GAAG,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;QAC5B,IAAI,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAC3B,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,KAAK,GAAG,EAAE,OAAO,EAAE,IAAI,GAAG,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC;YAC1C,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QACxB,CAAC;QACD,MAAM,QAAQ,GAAG,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;QACtC,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAC3C,IAAI,MAAM,KAAK,SAAS;YAAE,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;;YACtD,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACpB,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACtB,CAAC;IAED,MAAM,SAAS,GAAe,EAAE,CAAC;IACjC,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,KAAK,EAAE,CAAC;QACjC,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,GAAG,CAAC;YAAE,SAAS;QACrC,SAAS,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,UAAU,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC;IACnD,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC"}

package/dist/esm/integrity/assertion/types.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Assertion — one typed claim about one subject, with the two rules that
+ * give the algebra its teeth.
+ *
+ * Pattern: plain data + a keyed identity. Pure, structuredClone-safe.
+ * Role:    the Context Integrity substrate. Everything a seam adapter
+ *          hands a check is first normalised into assertions keyed by
+ *          `(subject, predicate, epoch)`, so every check compares one
+ *          shape and subject identity is READ off stamps, never inferred.
+ *
+ * THE TWO RULES:
+ *
+ * **Serving is asserting; history is quotation.** A tool schema on the
+ * wire asserts "available now"; a block labelled current-state asserts its
+ * contents as current. Transcript history is `quoted` — it legitimately
+ * holds superseded values, and checks never fire across the quoted
+ * stratum. This one distinction eliminates the false-positive class of
+ * stale-but-honest history with no judgment call.
+ *
+ * **Single-valued by default.** Two `asserted` assertions on one key with
+ * different values contradict; multi-valued predicates are the declared
+ * exception. Exemptions are declared, rules are never authored.
+ *
+ * Honest absence: a value that IS an unknown (a `Claim` whose kind is not
+ * `'known'`) never participates in a comparison — an unknown can neither
+ * corroborate nor contradict, and anything derived from it is unknown.
+ */
+/**
+ * A stamped identity edge — WHO a fact is about, written at the one moment
+ * the code demonstrably knows both ends (registration, mount, mint). The
+ * checker only ever reads these; it never infers identity. Facts without a
+ * shared stamped subject are incomparable, and incomparable means silent —
+ * which is why the disposition ledger counts `unreachable`.
+ */
+export interface SubjectRef {
+    /** What kind of thing — 'map' | 'skill' | 'tool' | 'action' | app kinds. Open by design. */
+    readonly kind: string;
+    readonly id: string;
+}
+/** The strata rule, as a type: only `asserted` facts can contradict. */
+export type AssertionStratum = 'asserted' | 'quoted';
+/** One typed claim about one subject. */
+export interface Assertion {
+    readonly subject: SubjectRef;
+    /** The relation this asserts — 'status', 'offered', 'position', … */
+    readonly predicate: string;
+    /**
+     * The claimed value. May be a plain value or a `Claim<T>`; a non-`known`
+     * Claim never participates in any comparison (honest absence).
+     */
+    readonly value: unknown;
+    /**
+     * The epoch this was asserted UNDER — a monotonic version from the
+     * subject's own counter (a session version, a cursor version). Two
+     * assertions at DIFFERENT epochs are history, not contradiction; absent
+     * means "the current, unversioned world", and only matches absent.
+     */
+    readonly epoch?: number;
+    readonly stratum: AssertionStratum;
+    /** Where this came from — one plain sentence or a source ref. */
+    readonly provenance: string;
+    /** The universal join key into commit logs and recordings, when known. */
+    readonly runtimeStageId?: string;
+    /** Dev-posture canary material — quarantined from every real count. */
+    readonly synthetic?: true;
+}
+/** The identity a single-valued comparison runs over. */
+export declare function assertionKey(a: Assertion): string;
+/** Same stamped subject — the only identity the algebra ever claims. */
+export declare function sameSubject(a: SubjectRef, b: SubjectRef): boolean;
+/** Does this value participate in comparisons? Unknowns never do. */
+export declare function participates(value: unknown): boolean;
+/** The comparable face of a value: a known Claim compares by its value. */
+export declare function comparableValueOf(value: unknown): unknown;

package/dist/esm/integrity/assertion/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/integrity/assertion/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AA8CH,yDAAyD;AACzD,MAAM,UAAU,YAAY,CAAC,CAAY;IACvC,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;IAC3D,OAAO,GAAG,CAAC,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC,CAAC,OAAO,CAAC,EAAE,IAAI,CAAC,CAAC,SAAS,IAAI,KAAK,EAAE,CAAC;AACrE,CAAC;AAED,wEAAwE;AACxE,MAAM,UAAU,WAAW,CAAC,CAAa,EAAE,CAAa;IACtD,OAAO,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC;AAC5C,CAAC;AAED,qEAAqE;AACrE,MAAM,UAAU,YAAY,CAAC,KAAc;IACzC,MAAM,KAAK,GAAG,KAAuC,CAAC;IACtD,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,KAAK,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;QAClF,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,IAAI,KAAK,CAAC,IAAI,KAAK,gBAAgB;YAAE,OAAO,KAAK,CAAC;IAChF,CAAC;IACD,OAAO,KAAK,KAAK,SAAS,CAAC;AAC7B,CAAC;AAED,2EAA2E;AAC3E,MAAM,UAAU,iBAAiB,CAAC,KAAc;IAC9C,MAAM,KAAK,GAAG,KAAuC,CAAC;IACtD,IACE,KAAK,KAAK,IAAI;QACd,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,CAAC,IAAI,KAAK,OAAO;QACtB,OAAO,IAAK,KAAgB,EAC5B,CAAC;QACD,OAAQ,KAA4B,CAAC,KAAK,CAAC;IAC7C,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/esm/integrity/dangling-reference/check.d.ts

@@ -0,0 +1,45 @@
+/**
+ * dangling-reference — a served capability whose declared argument ground
+ * has left the window and was not re-established.
+ *
+ * Pattern: pure function over three name sets; the closure check.
+ * Role:    the decidable fragment of "does everything the model is being
+ *          offered still have its evidence in reach?". The measured
+ *          failure: a `whats_here` result carrying the valid ids was
+ *          evicted by the window strategy while the tool that FIRES at
+ *          those ids stayed on the wire; the model assembled a plausible
+ *          id from memory and was refused. The drop already speaks
+ *          (9.57.0, `WindowRecord.droppedObservations`); this makes the
+ *          next composition answerable for it.
+ *
+ * DECLARED, NEVER INFERRED. The library cannot know that one tool's
+ * arguments come from another tool's results — only the author does. The
+ * edge is `Tool.argumentsFrom`, stamped at definition; a tool that
+ * declares nothing is never this check's subject, which is the whole
+ * zero-delta story.
+ *
+ * THE TWO FENCES, stated because they are the check's honesty:
+ * - A ground that was NEVER dropped is silent even with no result in the
+ *   window — the model simply has not called it yet, and offering the
+ *   dependent tool ahead of that is legitimate sequencing, not a defect.
+ * - A re-fetched ground (a fresh result present in the window) is silent
+ *   however many drops preceded it — the evidence is back in reach.
+ * The defect is exactly the third state: WAS grounded, evidence evicted,
+ * nothing re-established, capability still offered.
+ */
+import type { ContextError } from '../finding/types.js';
+/** One served tool and the grounds its author declared. */
+export interface ServedGroundedTool {
+    readonly name: string;
+    /** `Tool.argumentsFrom` — tool names whose results ground this one's arguments. */
+    readonly argumentsFrom: readonly string[];
+}
+/**
+ * Compare the served tools' declared grounds against what the window has
+ * dropped and what it currently holds.
+ *
+ * @param droppedResults tool names whose RESULTS have left the window this
+ *   run (union of `WindowRecord.droppedObservations`).
+ * @param presentResults tool names with a result currently IN the window.
+ */
+export declare function danglingReferencesOf(servedTools: readonly ServedGroundedTool[], droppedResults: ReadonlySet<string>, presentResults: ReadonlySet<string>, epoch: number): readonly ContextError[];

package/dist/esm/integrity/dangling-reference/check.js

@@ -0,0 +1,68 @@
+/**
+ * dangling-reference — a served capability whose declared argument ground
+ * has left the window and was not re-established.
+ *
+ * Pattern: pure function over three name sets; the closure check.
+ * Role:    the decidable fragment of "does everything the model is being
+ *          offered still have its evidence in reach?". The measured
+ *          failure: a `whats_here` result carrying the valid ids was
+ *          evicted by the window strategy while the tool that FIRES at
+ *          those ids stayed on the wire; the model assembled a plausible
+ *          id from memory and was refused. The drop already speaks
+ *          (9.57.0, `WindowRecord.droppedObservations`); this makes the
+ *          next composition answerable for it.
+ *
+ * DECLARED, NEVER INFERRED. The library cannot know that one tool's
+ * arguments come from another tool's results — only the author does. The
+ * edge is `Tool.argumentsFrom`, stamped at definition; a tool that
+ * declares nothing is never this check's subject, which is the whole
+ * zero-delta story.
+ *
+ * THE TWO FENCES, stated because they are the check's honesty:
+ * - A ground that was NEVER dropped is silent even with no result in the
+ *   window — the model simply has not called it yet, and offering the
+ *   dependent tool ahead of that is legitimate sequencing, not a defect.
+ * - A re-fetched ground (a fresh result present in the window) is silent
+ *   however many drops preceded it — the evidence is back in reach.
+ * The defect is exactly the third state: WAS grounded, evidence evicted,
+ * nothing re-established, capability still offered.
+ */
+/**
+ * Compare the served tools' declared grounds against what the window has
+ * dropped and what it currently holds.
+ *
+ * @param droppedResults tool names whose RESULTS have left the window this
+ *   run (union of `WindowRecord.droppedObservations`).
+ * @param presentResults tool names with a result currently IN the window.
+ */
+export function danglingReferencesOf(servedTools, droppedResults, presentResults, epoch) {
+    const findings = [];
+    for (const tool of servedTools) {
+        const missing = tool.argumentsFrom.filter((ground) => droppedResults.has(ground) && !presentResults.has(ground));
+        if (missing.length === 0)
+            continue;
+        findings.push({
+            kind: 'dangling-reference',
+            seam: 'compose',
+            subjects: [
+                { kind: 'tool', id: tool.name },
+                ...missing.map((id) => ({ kind: 'tool', id })),
+            ],
+            witnesses: missing.map((ground) => ({
+                subject: { kind: 'tool', id: tool.name },
+                predicate: 'argument-ground',
+                value: `results of '${ground}' evicted, not re-established`,
+                epoch,
+                stratum: 'asserted',
+                provenance: `window ledger: '${ground}' in droppedObservations, no result in window`,
+            })),
+            epoch,
+            message: `'${tool.name}' is being offered while the results that ground its arguments have left ` +
+                `the window (${missing.join(', ')}) and were not re-established. A call the model makes ` +
+                `with remembered values cannot be checked against evidence nobody can see — re-fetching ` +
+                `(calling ${missing.join(', ')} again) re-grounds it; nothing here withholds the tool.`,
+        });
+    }
+    return findings;
+}
+//# sourceMappingURL=check.js.map

package/dist/esm/integrity/dangling-reference/check.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check.js","sourceRoot":"","sources":["../../../../src/integrity/dangling-reference/check.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAYH;;;;;;;GAOG;AACH,MAAM,UAAU,oBAAoB,CAClC,WAA0C,EAC1C,cAAmC,EACnC,cAAmC,EACnC,KAAa;IAEb,MAAM,QAAQ,GAAmB,EAAE,CAAC;IACpC,KAAK,MAAM,IAAI,IAAI,WAAW,EAAE,CAAC;QAC/B,MAAM,OAAO,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,CACvC,CAAC,MAAM,EAAE,EAAE,CAAC,cAAc,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,MAAM,CAAC,CACtE,CAAC;QACF,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;YAAE,SAAS;QACnC,QAAQ,CAAC,IAAI,CAAC;YACZ,IAAI,EAAE,oBAAoB;YAC1B,IAAI,EAAE,SAAS;YACf,QAAQ,EAAE;gBACR,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,IAAI,CAAC,IAAI,EAAE;gBAC/B,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,EAAE,EAAc,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,CAAC;aAC3D;YACD,SAAS,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;gBAClC,OAAO,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,IAAI,CAAC,IAAI,EAAE;gBACxC,SAAS,EAAE,iBAAiB;gBAC5B,KAAK,EAAE,eAAe,MAAM,+BAA+B;gBAC3D,KAAK;gBACL,OAAO,EAAE,UAAmB;gBAC5B,UAAU,EAAE,mBAAmB,MAAM,+CAA+C;aACrF,CAAC,CAAC;YACH,KAAK;YACL,OAAO,EACL,IAAI,IAAI,CAAC,IAAI,2EAA2E;gBACxF,eAAe,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,wDAAwD;gBACzF,yFAAyF;gBACzF,YAAY,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,yDAAyD;SAC1F,CAAC,CAAC;IACL,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/dist/esm/integrity/disposition/lifecycle.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The disposition ledger's run lifecycle — registration, the dev canary,
+ * and nothing else.
+ *
+ * Pattern: two small functions bracketing a run; the ledger stays the one
+ *          accumulator, this file only decides WHO is registered and runs
+ *          the canary.
+ * Role:    a check is registered exactly when its preconditions exist on
+ *          THIS agent (wire: always — every run calls the model;
+ *          compose-invariant: a mount kernel is configured; dangling: at
+ *          least one tool declared `argumentsFrom`). Registration is what
+ *          makes silence auditable — an unregistered check is honest
+ *          absence, a registered one that never notes is the wiring rot
+ *          `assertAlive` exists to name.
+ *
+ * THE CANARY (dev posture): each registered check's PURE function is run
+ * once against a synthetic, deliberately contradictory fixture. A check
+ * that cannot catch its own canary is dead — it runs but cannot fire —
+ * which is theorem (ii); theorem (i), the unhooked pipeline, is what the
+ * real per-encounter notes prove. Canary findings never surface as events
+ * and never touch the real counts (`noteSynthetic` quarantine).
+ */
+import { type DispositionLedger } from './ledger.js';
+export type IntegrityPosture = 'observe' | 'dev';
+/** Which checks this agent's configuration makes applicable. */
+export interface IntegrityChecksPresent {
+    readonly wire: boolean;
+    readonly composeInvariant: boolean;
+    readonly dangling: boolean;
+}
+/**
+ * Start one run's ledger: register the present checks and, in dev posture,
+ * prove each can still catch its own synthetic defect.
+ */
+export declare function beginIntegrityRun(present: IntegrityChecksPresent, posture: IntegrityPosture): DispositionLedger;

package/dist/esm/integrity/disposition/lifecycle.js

@@ -0,0 +1,63 @@
+/**
+ * The disposition ledger's run lifecycle — registration, the dev canary,
+ * and nothing else.
+ *
+ * Pattern: two small functions bracketing a run; the ledger stays the one
+ *          accumulator, this file only decides WHO is registered and runs
+ *          the canary.
+ * Role:    a check is registered exactly when its preconditions exist on
+ *          THIS agent (wire: always — every run calls the model;
+ *          compose-invariant: a mount kernel is configured; dangling: at
+ *          least one tool declared `argumentsFrom`). Registration is what
+ *          makes silence auditable — an unregistered check is honest
+ *          absence, a registered one that never notes is the wiring rot
+ *          `assertAlive` exists to name.
+ *
+ * THE CANARY (dev posture): each registered check's PURE function is run
+ * once against a synthetic, deliberately contradictory fixture. A check
+ * that cannot catch its own canary is dead — it runs but cannot fire —
+ * which is theorem (ii); theorem (i), the unhooked pipeline, is what the
+ * real per-encounter notes prove. Canary findings never surface as events
+ * and never touch the real counts (`noteSynthetic` quarantine).
+ */
+import { dispositionLedger } from './ledger.js';
+import { invariantViolationsOf } from '../invariant-violation/check.js';
+import { wireViolationsOf } from '../invariant-violation/wire.js';
+import { danglingReferencesOf } from '../dangling-reference/check.js';
+/**
+ * Start one run's ledger: register the present checks and, in dev posture,
+ * prove each can still catch its own synthetic defect.
+ */
+export function beginIntegrityRun(present, posture) {
+    const ledger = dispositionLedger();
+    if (present.wire)
+        ledger.register('invariant-violation', 'wire');
+    if (present.composeInvariant)
+        ledger.register('invariant-violation', 'compose');
+    if (present.dangling)
+        ledger.register('dangling-reference', 'compose');
+    if (posture !== 'dev')
+        return ledger;
+    // The canaries — one known-bad fixture per registered check, through the
+    // REAL pure function. Epoch -1 marks them as no run iteration's business.
+    if (present.wire) {
+        ledger.noteSynthetic('invariant-violation', 'wire', 'minted');
+        const caught = wireViolationsOf({ names: ['canary_tool'], provenance: 'canary: composed frame' }, { names: ['canary_tool', 'canary_ghost'], provenance: 'canary: wire' }, -1);
+        if (caught.length > 0)
+            ledger.noteSynthetic('invariant-violation', 'wire', 'caught');
+    }
+    if (present.composeInvariant) {
+        ledger.noteSynthetic('invariant-violation', 'compose', 'minted');
+        const caught = invariantViolationsOf({ mapId: 'canary-map', standing: 'parked', iteration: -1, ownedToolNames: ['canary_tool'] }, { names: ['canary_tool'], provenance: 'canary: serving' });
+        if (caught.length > 0)
+            ledger.noteSynthetic('invariant-violation', 'compose', 'caught');
+    }
+    if (present.dangling) {
+        ledger.noteSynthetic('dangling-reference', 'compose', 'minted');
+        const caught = danglingReferencesOf([{ name: 'canary_tool', argumentsFrom: ['canary_ground'] }], new Set(['canary_ground']), new Set(), -1);
+        if (caught.length > 0)
+            ledger.noteSynthetic('dangling-reference', 'compose', 'caught');
+    }
+    return ledger;
+}
+//# sourceMappingURL=lifecycle.js.map

package/dist/esm/integrity/disposition/lifecycle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.js","sourceRoot":"","sources":["../../../../src/integrity/disposition/lifecycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,iBAAiB,EAA0B,MAAM,aAAa,CAAC;AACxE,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AACxE,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAWtE;;;GAGG;AACH,MAAM,UAAU,iBAAiB,CAC/B,OAA+B,EAC/B,OAAyB;IAEzB,MAAM,MAAM,GAAG,iBAAiB,EAAE,CAAC;IACnC,IAAI,OAAO,CAAC,IAAI;QAAE,MAAM,CAAC,QAAQ,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAC;IACjE,IAAI,OAAO,CAAC,gBAAgB;QAAE,MAAM,CAAC,QAAQ,CAAC,qBAAqB,EAAE,SAAS,CAAC,CAAC;IAChF,IAAI,OAAO,CAAC,QAAQ;QAAE,MAAM,CAAC,QAAQ,CAAC,oBAAoB,EAAE,SAAS,CAAC,CAAC;IACvE,IAAI,OAAO,KAAK,KAAK;QAAE,OAAO,MAAM,CAAC;IAErC,yEAAyE;IACzE,0EAA0E;IAC1E,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;QACjB,MAAM,CAAC,aAAa,CAAC,qBAAqB,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;QAC9D,MAAM,MAAM,GAAG,gBAAgB,CAC7B,EAAE,KAAK,EAAE,CAAC,aAAa,CAAC,EAAE,UAAU,EAAE,wBAAwB,EAAE,EAChE,EAAE,KAAK,EAAE,CAAC,aAAa,EAAE,cAAc,CAAC,EAAE,UAAU,EAAE,cAAc,EAAE,EACtE,CAAC,CAAC,CACH,CAAC;QACF,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC;YAAE,MAAM,CAAC,aAAa,CAAC,qBAAqB,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;IACvF,CAAC;IACD,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC;QAC7B,MAAM,CAAC,aAAa,CAAC,qBAAqB,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAC;QACjE,MAAM,MAAM,GAAG,qBAAqB,CAClC,EAAE,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,cAAc,EAAE,CAAC,aAAa,CAAC,EAAE,EAC3F,EAAE,KAAK,EAAE,CAAC,aAAa,CAAC,EAAE,UAAU,EAAE,iBAAiB,EAAE,CAC1D,CAAC;QACF,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC;YAAE,MAAM,CAAC,aAAa,CAAC,qBAAqB,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAC;IAC1F,CAAC;IACD,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;QACrB,MAAM,CAAC,aAAa,CAAC,oBAAoB,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAC;QAChE,MAAM,MAAM,GAAG,oBAAoB,CACjC,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,aAAa,EAAE,CAAC,eAAe,CAAC,EAAE,CAAC,EAC3D,IAAI,GAAG,CAAC,CAAC,eAAe,CAAC,CAAC,EAC1B,IAAI,GAAG,EAAE,EACT,CAAC,CAAC,CACH,CAAC;QACF,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC;YAAE,MAAM,CAAC,aAAa,CAAC,oBAAoB,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAC;IACzF,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/esm/integrity/finding/types.d.ts

@@ -0,0 +1,57 @@
+/**
+ * ContextError — the ONE visible finding type, named in the words people
+ * already use for these defects.
+ *
+ * Pattern: plain data + identity-keyed dedup. Pure.
+ * Role:    everything a Context Integrity check detects is filed as
+ *          exactly this shape, at every seam — a uniform finding is what
+ *          makes findings a CORPUS (each one a labelled instance carrying
+ *          its check, seam, subjects and witnesses) and what keeps the
+ *          disposition accounting honest across seams.
+ *
+ * NAMING LAW: the `kind` is the plain software-defect name, never the
+ * algebra term — the people reading a finding are not reading the
+ * mechanism. The one guardrail that outranks the naming: never use a
+ * familiar name that is subtly wrong. ("State loss" for the evicted-
+ * identifiers failure would send an engineer hunting a storage bug that
+ * does not exist; the ledger held every identifier — they stopped being
+ * SERVED. `dangling-reference` is what a linker means and what happened.)
+ */
+import type { Assertion, SubjectRef } from '../assertion/types.js';
+import type { IntegritySeam } from '../disposition/types.js';
+/**
+ * The five defect classes, by their plain names:
+ *
+ * | kind | means | mechanism |
+ * |---|---|---|
+ * | `invariant-violation`  | two things that cannot both be true were both asserted | exclusion |
+ * | `unsupported-argument` | acted on a value nothing served                        | domain    |
+ * | `dangling-reference`   | offered an action whose inputs are no longer available | closure   |
+ * | `duplicate-execution`  | did settled work again                                 | once      |
+ * | `unsupported-claim`    | stated something the record does not support           | grounding |
+ */
+export type ContextErrorKind = 'invariant-violation' | 'unsupported-argument' | 'dangling-reference' | 'duplicate-execution' | 'unsupported-claim';
+/** One detected context error — a labelled instance, automatically. */
+export interface ContextError {
+    readonly kind: ContextErrorKind;
+    readonly seam: IntegritySeam;
+    /** The stamped subjects this is about. */
+    readonly subjects: readonly SubjectRef[];
+    /** The two-or-more assertions that prove it — copies, plain data. */
+    readonly witnesses: readonly Assertion[];
+    /** The epoch the conflict was judged at, when the witnesses carry one. */
+    readonly epoch?: number;
+    /** True when every witness is canary material — never mixed with real. */
+    readonly synthetic?: true;
+    /** One plain sentence a person can act on. States the defect, never a verdict on who is right. */
+    readonly message: string;
+}
+/**
+ * The identity a finding deduplicates by: the same defect about the same
+ * subjects at the same seam is ONE finding however many passes re-detect
+ * it — a findings channel that spams recreates the noise problem it
+ * exists to prevent.
+ */
+export declare function contextErrorIdentity(e: ContextError): string;
+/** Keep the FIRST filing of each identity, in input order. */
+export declare function dedupeContextErrors(errors: readonly ContextError[]): readonly ContextError[];

package/dist/esm/integrity/finding/types.js

@@ -0,0 +1,47 @@
+/**
+ * ContextError — the ONE visible finding type, named in the words people
+ * already use for these defects.
+ *
+ * Pattern: plain data + identity-keyed dedup. Pure.
+ * Role:    everything a Context Integrity check detects is filed as
+ *          exactly this shape, at every seam — a uniform finding is what
+ *          makes findings a CORPUS (each one a labelled instance carrying
+ *          its check, seam, subjects and witnesses) and what keeps the
+ *          disposition accounting honest across seams.
+ *
+ * NAMING LAW: the `kind` is the plain software-defect name, never the
+ * algebra term — the people reading a finding are not reading the
+ * mechanism. The one guardrail that outranks the naming: never use a
+ * familiar name that is subtly wrong. ("State loss" for the evicted-
+ * identifiers failure would send an engineer hunting a storage bug that
+ * does not exist; the ledger held every identifier — they stopped being
+ * SERVED. `dangling-reference` is what a linker means and what happened.)
+ */
+/**
+ * The identity a finding deduplicates by: the same defect about the same
+ * subjects at the same seam is ONE finding however many passes re-detect
+ * it — a findings channel that spams recreates the noise problem it
+ * exists to prevent.
+ */
+export function contextErrorIdentity(e) {
+    const subjects = e.subjects
+        .map((s) => `${s.kind} ${s.id}`)
+        .sort()
+        .join(' + ');
+    const epoch = e.epoch === undefined ? '' : String(e.epoch);
+    return `${e.kind} @${e.seam} [${subjects}] ${epoch}`;
+}
+/** Keep the FIRST filing of each identity, in input order. */
+export function dedupeContextErrors(errors) {
+    const seen = new Set();
+    const kept = [];
+    for (const e of errors) {
+        const id = contextErrorIdentity(e);
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        kept.push(e);
+    }
+    return kept;
+}
+//# sourceMappingURL=types.js.map

package/dist/esm/integrity/finding/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/integrity/finding/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAuCH;;;;;GAKG;AACH,MAAM,UAAU,oBAAoB,CAAC,CAAe;IAClD,MAAM,QAAQ,GAAG,CAAC,CAAC,QAAQ;SACxB,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,EAAE,CAAC;SAC/B,IAAI,EAAE;SACN,IAAI,CAAC,KAAK,CAAC,CAAC;IACf,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;IAC3D,OAAO,GAAG,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,IAAI,KAAK,QAAQ,KAAK,KAAK,EAAE,CAAC;AACvD,CAAC;AAED,8DAA8D;AAC9D,MAAM,UAAU,mBAAmB,CAAC,MAA+B;IACjE,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,MAAM,IAAI,GAAmB,EAAE,CAAC;IAChC,KAAK,MAAM,CAAC,IAAI,MAAM,EAAE,CAAC;QACvB,MAAM,EAAE,GAAG,oBAAoB,CAAC,CAAC,CAAC,CAAC;QACnC,IAAI,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;YAAE,SAAS;QAC3B,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QACb,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACf,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}