rea-agents 6.1.0 → 6.2.0

package/dist/domain/javascript/javascriptSemanticMemberMutations.js

@@ -2,10 +2,17 @@ import * as t from "@babel/types";
 import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
 import { evaluateSemanticBinding } from "./javascriptSemanticValues.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
-import { semanticStaticPropertyKey, semanticStaticPropertyName, } from "./javascriptAstValues.js";
+import { semanticStaticPropertyKey } from "./javascriptAstValues.js";
 /** Keep explicit property mutations outside the initializer-only value lattice. */
 export const collectSemanticMemberMutations = (program, state) => {
-    const markValue = (node, path, bindings) => {
+    const parents = new WeakMap();
+    traverseJavaScriptAst(program, {
+        enter: (node, parent) => {
+            if (parent !== null)
+                parents.set(node, parent);
+        },
+    });
+    const markValue = (node, path, bindings, mutation) => {
         if (t.isIdentifier(node)) {
             const binding = resolveSemanticBindingState(state, node, node.name);
             if (binding === undefined || bindings.has(binding.bindingId))
@@ -15,8 +22,8 @@ export const collectSemanticMemberMutations = (program, state) => {
                 return;
             binding.mutatedPaths.push(path);
             const nested = new Set([...bindings, binding.bindingId]);
-            for (const initializer of binding.initializers)
-                markValue(initializer.node, [...initializer.projection, ...path], nested);
+            for (const initializer of mutationInitializers(binding, mutation, parents))
+                markValue(initializer.node, [...initializer.projection, ...path], nested, mutation);
             return;
         }
         if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
@@ -27,42 +34,92 @@ export const collectSemanticMemberMutations = (program, state) => {
                 members.push(semanticStaticPropertyKey(current.property, current.computed));
                 current = current.object;
             }
-            markValue(current, [...members.reverse(), ...path], bindings);
+            markValue(current, [...members.reverse(), ...path], bindings, mutation);
             return;
         }
         for (const value of referencedValues(node, path))
-            markValue(value.node, value.path, bindings);
+            markValue(value.node, value.path, bindings, mutation);
     };
-    const markTarget = (node) => {
+    const markTarget = (node, mutation) => {
         if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node))
-            markValue(node.object, [semanticStaticPropertyKey(node.property, node.computed)], new Set());
+            markValue(node.object, [semanticStaticPropertyKey(node.property, node.computed)], new Set(), mutation);
         else if (t.isRestElement(node))
-            markTarget(node.argument);
+            markTarget(node.argument, mutation);
         else if (t.isAssignmentPattern(node))
-            markTarget(node.left);
+            markTarget(node.left, mutation);
         else if (t.isArrayPattern(node)) {
             for (const element of node.elements)
                 if (element !== null)
-                    markTarget(element);
+                    markTarget(element, mutation);
         }
         else if (t.isObjectPattern(node)) {
             for (const property of node.properties)
-                markTarget(t.isRestElement(property) ? property.argument : property.value);
+                markTarget(t.isRestElement(property) ? property.argument : property.value, mutation);
         }
     };
     traverseJavaScriptAst(program, {
         enter: (node) => {
             if (t.isAssignmentExpression(node))
-                markTarget(node.left);
+                markTarget(node.left, node);
             else if (t.isUpdateExpression(node))
-                markTarget(node.argument);
+                markTarget(node.argument, node);
             else if (t.isUnaryExpression(node, { operator: "delete" }))
-                markTarget(node.argument);
+                markTarget(node.argument, node);
             else if (t.isForOfStatement(node) || t.isForInStatement(node))
-                markTarget(node.left);
+                markTarget(node.left, node);
         },
     });
 };
+const statementPosition = (statement, parents) => {
+    const parent = parents.get(statement);
+    if (!t.isProgram(parent) && !t.isBlockStatement(parent))
+        return null;
+    const index = parent.body.indexOf(statement);
+    return index < 0 ? null : { body: parent.body, index };
+};
+const directInitializerPosition = (node, parents) => {
+    const parent = parents.get(node);
+    if (t.isVariableDeclarator(parent) && parent.init === node) {
+        const declaration = parents.get(parent);
+        return t.isVariableDeclaration(declaration)
+            ? statementPosition(declaration, parents)
+            : null;
+    }
+    if (t.isAssignmentExpression(parent) &&
+        parent.operator === "=" &&
+        parent.right === node &&
+        t.isIdentifier(parent.left)) {
+        const statement = parents.get(parent);
+        return t.isExpressionStatement(statement) && statement.expression === parent
+            ? statementPosition(statement, parents)
+            : null;
+    }
+    return null;
+};
+const directMutationPosition = (node, parents) => {
+    if (!t.isAssignmentExpression(node) &&
+        !t.isUpdateExpression(node) &&
+        !t.isUnaryExpression(node, { operator: "delete" }))
+        return null;
+    const statement = parents.get(node);
+    return t.isExpressionStatement(statement) && statement.expression === node
+        ? statementPosition(statement, parents)
+        : null;
+};
+const mutationInitializers = (binding, mutation, parents) => {
+    if (binding.initializers.length < 2)
+        return binding.initializers;
+    const mutationPosition = directMutationPosition(mutation, parents);
+    if (mutationPosition === null)
+        return binding.initializers;
+    const positions = binding.initializers.map(({ node }) => directInitializerPosition(node, parents));
+    if (positions.some((position) => position === null ||
+        position.body !== mutationPosition.body ||
+        position.index >= mutationPosition.index))
+        return binding.initializers;
+    const latestIndex = positions.reduce((latest, position) => Math.max(latest, position?.index ?? -1), -1);
+    return binding.initializers.filter((_, index) => positions[index]?.index === latestIndex);
+};
 const referencedValues = (node, path) => {
     const [key, ...remaining] = path;
     // An initializer owns its slots; only deeper writes can affect shared children.
@@ -74,10 +131,8 @@ const referencedValues = (node, path) => {
                     return [{ node: property.argument, path }];
                 if (!t.isObjectProperty(property))
                     return [];
-                const name = semanticStaticPropertyName(property.key, property.computed);
-                return key === null ||
-                    (name === "" && !t.isStringLiteral(property.key, { value: "" })) ||
-                    String(key) === name
+                const name = semanticStaticPropertyKey(property.key, property.computed);
+                return key === null || name === null || String(key) === name
                     ? [{ node: property.value, path: remaining }]
                     : [];
             });
@@ -112,5 +167,7 @@ const referencedValues = (node, path) => {
             { node: node.left, path },
             { node: node.right, path },
         ];
+    if (t.isAssignmentExpression(node, { operator: "&&=" }))
+        return [{ node: node.right, path }];
     return [];
 };

package/dist/domain/javascript/javascriptSemanticMutationValues.js

@@ -13,41 +13,35 @@ export const invalidateSemanticMutationPath = (value, path) => {
         const properties = value.properties.map((property) => property.name === name
             ? {
                 ...property,
+                ...(remaining.length === 0
+                    ? { presence: "unknown-coverage" }
+                    : {}),
                 value: invalidateSemanticMutationPath(property.value, remaining),
             }
             : property);
-        return value.unknownProperties || !observed
-            ? {
-                status: "object",
-                properties,
-                unknownProperties: true,
-                omittedProperties: observed ? value.omittedProperties : null,
-            }
-            : {
-                status: "object",
-                properties,
-                unknownProperties: false,
-                omittedProperties: 0,
-            };
+        if (!observed)
+            properties.push({ name, value: unknown, presence: "unknown-coverage" });
+        return { ...value, properties };
     }
     if (value.status === "array") {
-        const index = typeof key === "number" ? key : Number(key);
-        if (!Number.isSafeInteger(index) ||
-            index < 0 ||
-            String(index) !== String(key))
+        const name = String(key);
+        // Array length writes can remove every index; ordinary named properties
+        // and sparse indices affect only their own slot.
+        if (name === "length")
             return unknown;
-        const observed = value.items[index] !== undefined;
-        const items = value.items.map((item, position) => position === index
-            ? invalidateSemanticMutationPath(item, remaining)
-            : item);
-        return value.unknownItems || !observed
+        const observed = value.items.some((item) => item.name === name);
+        const items = value.items.map((item) => item.name === name
             ? {
-                status: "array",
-                items,
-                unknownItems: true,
-                omittedItems: observed ? value.omittedItems : null,
+                ...item,
+                presence: remaining.length === 0
+                    ? "unknown-coverage"
+                    : item.presence,
+                value: invalidateSemanticMutationPath(item.value, remaining),
             }
-            : { status: "array", items, unknownItems: false, omittedItems: 0 };
+            : item);
+        if (!observed)
+            items.push({ name, presence: "unknown-coverage", value: unknown });
+        return { ...value, items };
     }
     return unknown;
 };

package/dist/domain/javascript/javascriptSemanticObjects.js

@@ -1,5 +1,6 @@
 import * as t from "@babel/types";
-import { semanticCallableIdForNode, semanticReadsBeforeWrite, semanticStaticPropertyKey, } from "./javascriptSemanticProjection.js";
+import { semanticCallableIdForNode, semanticReadsBeforeWrite, } from "./javascriptSemanticProjection.js";
+import { semanticStaticPropertyKey } from "./javascriptAstValues.js";
 import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";
@@ -19,16 +20,19 @@ export const collectJavaScriptSemanticObjects = (program, state, callables) => {
                 collectMember(node, parent, ownerCallableId, context);
             else if (t.isSpreadElement(node) &&
                 parent !== null &&
-                t.isObjectExpression(parent))
+                t.isObjectExpression(parent)) {
+                const identity = expressionObjectIdentity(node.argument, state);
                 addObjectOperation({
                     node,
                     kind: "spread",
                     ownerCallableId,
-                    objectBindingId: expressionBindingId(node.argument, state),
+                    objectBindingId: identity.bindingId,
                     targetBindingId: null,
-                    propertyName: null,
+                    propertyPath: identity.path,
                 }, state, output);
-            else if (t.isVariableDeclarator(node) && t.isObjectPattern(node.id))
+            }
+            else if (t.isVariableDeclarator(node) &&
+                (t.isObjectPattern(node.id) || t.isArrayPattern(node.id)))
                 collectDestructuring(node, ownerCallableId, state, output);
         },
         exit: (node) => {
@@ -41,9 +45,12 @@ export const collectJavaScriptSemanticObjects = (program, state, callables) => {
 };
 const collectMember = (node, parent, ownerCallableId, context) => {
     const { state, output } = context;
-    const name = semanticStaticPropertyKey(node.property, node.computed);
-    if (name === null)
+    // A chain is one property access; retaining every prefix duplicates work and
+    // would make full paths quadratic in deeply nested producer expressions.
+    if ((t.isMemberExpression(parent) || t.isOptionalMemberExpression(parent)) &&
+        parent.object === node)
         return;
+    const identity = expressionObjectIdentity(node, state);
     const write = (t.isAssignmentExpression(parent) && parent.left === node) ||
         (t.isUpdateExpression(parent) && parent.argument === node);
     const readsBeforeWrite = write && semanticReadsBeforeWrite(node, parent);
@@ -52,42 +59,53 @@ const collectMember = (node, parent, ownerCallableId, context) => {
             node,
             kind: "read",
             ownerCallableId,
-            objectBindingId: expressionBindingId(node.object, state),
+            objectBindingId: identity.bindingId,
             targetBindingId: null,
-            propertyName: name,
+            propertyPath: identity.path,
         }, state, output);
     addObjectOperation({
         node,
         kind: write ? "write" : "read",
         ownerCallableId,
-        objectBindingId: expressionBindingId(node.object, state),
+        objectBindingId: identity.bindingId,
         targetBindingId: null,
-        propertyName: name,
+        propertyPath: identity.path,
     }, state, output);
 };
 const collectDestructuring = (node, ownerCallableId, state, output) => {
-    if (!t.isObjectPattern(node.id))
-        return;
-    const objectBindingId = expressionBindingId(node.init, state);
-    for (const property of node.id.properties) {
-        if (!t.isObjectProperty(property))
-            continue;
-        const name = semanticStaticPropertyKey(property.key, property.computed);
-        if (name === null)
-            continue;
-        const target = bindingIdentifier(property.value);
+    const source = expressionObjectIdentity(node.init, state);
+    const visit = (pattern, path) => {
+        if (t.isObjectPattern(pattern)) {
+            for (const property of pattern.properties) {
+                if (!t.isObjectProperty(property))
+                    continue;
+                const name = semanticStaticPropertyKey(property.key, property.computed);
+                if (name !== null)
+                    visit(property.value, [...path, name]);
+            }
+            return;
+        }
+        if (t.isArrayPattern(pattern)) {
+            pattern.elements.forEach((element, index) => {
+                if (element !== null && !t.isRestElement(element))
+                    visit(element, [...path, String(index)]);
+            });
+            return;
+        }
+        const target = bindingIdentifier(pattern);
+        if (target === null)
+            return;
         addObjectOperation({
-            node: property,
+            node: pattern,
             kind: "destructure",
             ownerCallableId,
-            objectBindingId,
-            targetBindingId: target === null
-                ? null
-                : (resolveSemanticBindingState(state, target, target.name)
-                    ?.bindingId ?? null),
-            propertyName: name,
+            objectBindingId: source.bindingId,
+            targetBindingId: resolveSemanticBindingState(state, target, target.name)?.bindingId ??
+                null,
+            propertyPath: source.path === null ? null : [...source.path, ...path],
         }, state, output);
-    }
+    };
+    visit(node.id, []);
 };
 const addObjectOperation = (input, state, output) => {
     output.push({
@@ -97,21 +115,44 @@ const addObjectOperation = (input, state, output) => {
         ownerCallableId: input.ownerCallableId,
         objectBindingId: input.objectBindingId,
         targetBindingId: input.targetBindingId,
-        propertyName: input.propertyName,
-        resolution: input.kind === "spread"
-            ? input.objectBindingId === null
-                ? "partial"
-                : "complete"
-            : input.objectBindingId === null ||
-                input.propertyName === null ||
-                (input.kind === "destructure" && input.targetBindingId === null)
-                ? "partial"
-                : "complete",
+        propertyPath: input.propertyPath,
+        resolution: input.objectBindingId === null ||
+            input.propertyPath === null ||
+            (input.kind === "destructure" && input.targetBindingId === null)
+            ? "partial"
+            : "complete",
     });
 };
-const expressionBindingId = (node, state) => t.isIdentifier(node)
-    ? (resolveSemanticBindingState(state, node, node.name)?.bindingId ?? null)
-    : null;
+const expressionObjectIdentity = (node, state) => {
+    const path = [];
+    let current = node;
+    let staticPath = true;
+    while (current !== null && current !== undefined) {
+        if (t.isMemberExpression(current) ||
+            t.isOptionalMemberExpression(current)) {
+            const name = semanticStaticPropertyKey(current.property, current.computed);
+            if (name === null)
+                staticPath = false;
+            else
+                path.push(name);
+            current = current.object;
+        }
+        else if (t.isTSAsExpression(current) ||
+            t.isTSTypeAssertion(current) ||
+            t.isTSNonNullExpression(current) ||
+            t.isTSSatisfiesExpression(current))
+            current = current.expression;
+        else
+            break;
+    }
+    return {
+        bindingId: t.isIdentifier(current)
+            ? (resolveSemanticBindingState(state, current, current.name)?.bindingId ??
+                null)
+            : null,
+        path: staticPath ? path.reverse() : null,
+    };
+};
 const bindingIdentifier = (node) => {
     if (t.isIdentifier(node))
         return node;

package/dist/domain/javascript/javascriptSemanticPrimitives.js

@@ -1,13 +1,6 @@
-import * as t from "@babel/types";
 import { compareCodePoints } from "../canonicalOrdering.js";
 import { semanticPrimitiveKey } from "./javascriptSemanticProvenance.js";
-import { readExactJavaScriptLiteral } from "./javascriptAstValues.js";
 import { SEMANTIC_PRIMITIVE_CANDIDATE_LIMIT, exceedsSemanticPrimitiveStringByteBudget, semanticResourceLimitUnknown, } from "./javascriptSemanticResourceLimits.js";
-/**
- * Keep eight independent binary choices exact, while bounding the next
- * exponential expansion before it allocates hundreds more alternatives.
- */
-export const MAX_SEMANTIC_PRIMITIVE_CANDIDATES = SEMANTIC_PRIMITIVE_CANDIDATE_LIMIT;
 /** Normalize one bounded collection of possible primitive values. */
 export const semanticPrimitiveSet = (values) => {
     const uniqueValues = new Set();
@@ -18,7 +11,7 @@ export const semanticPrimitiveSet = (values) => {
                 reason: "Nonfinite numbers are outside the JSON primitive lattice.",
             };
         uniqueValues.add(value);
-        if (uniqueValues.size > MAX_SEMANTIC_PRIMITIVE_CANDIDATES)
+        if (uniqueValues.size > SEMANTIC_PRIMITIVE_CANDIDATE_LIMIT)
             return semanticResourceLimitUnknown("primitive-candidates");
     }
     if (exceedsSemanticPrimitiveStringByteBudget([...uniqueValues].flatMap((value) => typeof value === "string" ? [value] : [])))
@@ -38,7 +31,3 @@ export const semanticPrimitiveCandidates = (value) => value.status === "literal"
     : value.status === "union"
         ? value.values
         : null;
-/** Parse one Babel primitive literal without evaluating code. */
-export const semanticPrimitiveValue = (node) => {
-    return readExactJavaScriptLiteral(node);
-};

package/dist/domain/javascript/javascriptSemanticProjection.js

@@ -4,8 +4,8 @@ import { semanticRequireOrigin } from "./javascriptSemanticRequireOrigin.js";
 import { compareCodePoints } from "../canonicalOrdering.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 import { evaluateSemanticBinding, evaluateSemanticProvenance, } from "./javascriptSemanticValues.js";
-import { propertyName, range, stringValue, } from "./javascriptStaticAnalysisHelpers.js";
-import { semanticStaticPropertyKey } from "./javascriptAstValues.js";
+import { range, stringValue } from "./javascriptStaticAnalysisHelpers.js";
+import { propertyName, semanticStaticPropertyKey, } from "./javascriptAstValues.js";
 /** Retain callable identity without polluting lexical bindings. */
 export const collectSemanticCallable = (input) => {
     const { node, parent, containerScope, bodyScope, state } = input;
@@ -136,7 +136,6 @@ export const immutableSemanticBindings = (state) => [...state.bindingsById.value
     provenance: evaluateSemanticProvenance(binding, state),
 }))
     .sort((left, right) => compareCodePoints(left.bindingId, right.bindingId));
-export { semanticStaticPropertyKey, semanticStaticPropertyName, } from "./javascriptAstValues.js";
 const callableKind = (node) => {
     if (t.isClassMethod(node) ||
         t.isClassPrivateMethod(node) ||

package/dist/domain/javascript/javascriptSemanticPromises.js

@@ -1,5 +1,6 @@
 import * as t from "@babel/types";
-import { semanticCallableIdForNode, semanticStaticPropertyName, } from "./javascriptSemanticProjection.js";
+import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
+import { semanticStaticPropertyName } from "./javascriptAstValues.js";
 import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
 import { compareCodePoints } from "../canonicalOrdering.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";

package/dist/domain/javascript/javascriptSemanticResourceLimits.js

@@ -69,7 +69,7 @@ export const semanticResourceLimitsIn = (values) => {
                 pending.push(property.value);
         else if (value.status === "array")
             for (const item of value.items)
-                pending.push(item);
+                pending.push(item.value);
     }
     return [...found].sort();
 };

package/dist/domain/javascript/javascriptSemanticResources.js

@@ -1,6 +1,6 @@
 import * as t from "@babel/types";
 import { semanticBuiltinNamespacePath } from "./javascriptSemanticProvenance.js";
-import { semanticStaticPropertyName } from "./javascriptSemanticProjection.js";
+import { semanticStaticPropertyName } from "./javascriptAstValues.js";
 import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
 import { dataEffectMemberCallee, outerDataEffectBinding, traverseDataEffects, } from "./javascriptSemanticDataEffectHelpers.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";

package/dist/domain/javascript/javascriptSemanticReturns.js

@@ -1,4 +1,5 @@
 import * as t from "@babel/types";
+import { semanticContainer, semanticPropertyPointer, } from "./javascriptSemanticSlots.js";
 import { compareCodePoints } from "../canonicalOrdering.js";
 import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
 import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
@@ -137,35 +138,49 @@ export const flattenSemanticReturnValue = (value) => {
     propertyCoverage.sort((left, right) => compareCodePoints(left.path, right.path));
     return { fields, propertyCoverage };
 };
-const flattenValue = (value, path, fields, coverage) => {
+const flattenValue = (value, path, fields, coverage, presence = "present") => {
+    if (presence !== "present") {
+        fields.push({
+            path,
+            presence,
+            state: "unknown",
+            value: null,
+            reason: "reason" in value ? value.reason : "Property presence is uncertain.",
+        });
+        return;
+    }
     if (value.status === "literal") {
-        fields.push({ path, state: "literal", value: value.value, reason: null });
+        fields.push({
+            path,
+            presence,
+            state: "literal",
+            value: value.value,
+            reason: null,
+        });
         return;
     }
     if (value.status === "union") {
         fields.push({
             path,
+            presence,
             state: "union",
             value: [...value.values],
             reason: null,
         });
         return;
     }
-    if (value.status === "object") {
-        coverage.push(value.unknownProperties
-            ? { path, status: "partial", omitted: value.omittedProperties }
-            : { path, status: "complete", omitted: 0 });
-        for (const property of value.properties)
-            flattenValue(property.value, `${path}/${escapePointer(property.name)}`, fields, coverage);
-        return;
-    }
-    if (value.status === "array") {
-        coverage.push(value.unknownItems
-            ? { path, status: "partial", omitted: value.omittedItems }
-            : { path, status: "complete", omitted: 0 });
-        value.items.forEach((item, index) => flattenValue(item, `${path}/${String(index)}`, fields, coverage));
+    if ("reason" in value) {
+        fields.push({
+            path,
+            presence,
+            state: "unknown",
+            value: null,
+            reason: value.reason,
+        });
         return;
     }
-    fields.push({ path, state: "unknown", value: null, reason: value.reason });
+    const container = semanticContainer(value);
+    coverage.push({ path, ...container.coverage });
+    for (const slot of container.slots)
+        flattenValue(slot.value, `${path}${semanticPropertyPointer([slot.name])}`, fields, coverage, slot.presence);
 };
-const escapePointer = (value) => value.replaceAll("~", "~0").replaceAll("/", "~1");

package/dist/domain/javascript/javascriptSemanticSlots.js

@@ -0,0 +1,72 @@
+export function semanticContainer(value) {
+    if (value.status === "object")
+        return {
+            slots: value.properties,
+            coverage: value.unknownProperties
+                ? { status: "partial", omitted: value.omittedProperties }
+                : { status: "complete", omitted: 0 },
+        };
+    if (value.status === "array")
+        return {
+            slots: value.items,
+            coverage: value.unknownItems
+                ? { status: "partial", omitted: value.omittedItems }
+                : { status: "complete", omitted: 0 },
+        };
+    return null;
+}
+/** Resolve a full static own-property path without conflating missing siblings. */
+export const semanticSlotAtPath = (value, path) => {
+    const leafName = path.at(-1) ?? "";
+    let current = {
+        name: "",
+        presence: "present",
+        value,
+    };
+    for (const [index, name] of path.entries()) {
+        const container = semanticContainer(current.value);
+        if (current.presence !== "present" || container === null)
+            return {
+                name: leafName,
+                presence: "unknown-coverage",
+                value: "reason" in current.value
+                    ? {
+                        ...current.value,
+                        reason: `${current.value.reason} Cannot continue ${semanticPropertyPointer(path)} through receiver ${semanticPropertyPointer(path.slice(0, index))}.`,
+                    }
+                    : {
+                        status: "unknown",
+                        reason: `Cannot resolve ${semanticPropertyPointer(path)} through ${current.value.status} receiver ${semanticPropertyPointer(path.slice(0, index))}.`,
+                    },
+            };
+        // Array position inventories omit the intrinsic non-enumerable length slot.
+        // Its own presence is guaranteed even when no exact length is retained.
+        if (current.value.status === "array" && name === "length") {
+            current = {
+                name,
+                presence: "present",
+                value: {
+                    status: "unknown",
+                    reason: "Array length is present but its value is not retained.",
+                },
+            };
+            continue;
+        }
+        const observed = container.slots.find((slot) => slot.name === name);
+        current = observed ?? {
+            name,
+            presence: container.coverage.status === "complete"
+                ? "absent"
+                : "unknown-coverage",
+            value: {
+                status: "unknown",
+                reason: `Own property ${name} was not observed.`,
+            },
+        };
+    }
+    return current;
+};
+/** Encode path segments as an unambiguous JSON Pointer, preserving empty keys. */
+export const semanticPropertyPointer = (path) => path
+    .map((key) => `/${key.replaceAll("~", "~0").replaceAll("/", "~1")}`)
+    .join("");