@tangle-network/agent-interface 0.37.0 → 0.39.0

package/dist/agent-profile-activation.d.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import type { Sha256Digest } from "./agent-candidate.js";
+/** One exact native file applied before an agent process starts. */
+export interface AgentProfileActivationFileEvidence {
+    path: string;
+    mode: number;
+    content: string;
+}
+/**
+ * Shared evidence carried by every exact profile activation.
+ *
+ * The plan type remains owned by the producer because ordinary agent runs and
+ * sealed benchmark runs have different plan contracts. The applied file bytes
+ * and activation identity are shared so those producers cannot invent
+ * competing activation evidence.
+ */
+export interface AgentProfileActivationEvidence<TProfilePlan = unknown> {
+    profilePlan: TProfilePlan;
+    files: AgentProfileActivationFileEvidence[];
+    digest: Sha256Digest;
+}
+/** Runtime validator for one exact native profile file. */
+export declare const agentProfileActivationFileEvidenceSchema: z.ZodObject<{
+    path: z.ZodString;
+    mode: z.ZodNumber;
+    content: z.ZodString;
+}, z.core.$strict>;
+/**
+ * Compose the shared activation evidence with a producer-owned exact plan.
+ * Candidate materialization uses this factory and adds its stronger plan/file
+ * consistency checks around the resulting schema.
+ */
+export declare function createAgentProfileActivationEvidenceSchema<TProfilePlan>(profilePlanSchema: z.ZodType<TProfilePlan>): z.ZodObject<{
+    profilePlan: z.ZodType<TProfilePlan, unknown, z.core.$ZodTypeInternals<TProfilePlan, unknown>>;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        mode: z.ZodNumber;
+        content: z.ZodString;
+    }, z.core.$strict>>;
+    digest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+}, z.core.$strict>;

package/dist/agent-profile-activation.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { isSafeRelativePath, isWellFormedUnicode, sha256DigestSchema, } from "./agent-candidate-schema-common.js";
+/** Runtime validator for one exact native profile file. */
+export const agentProfileActivationFileEvidenceSchema = z.strictObject({
+    path: z
+        .string()
+        .refine((value) => isSafeRelativePath(value, false), "profile activation file must use a canonical relative path"),
+    mode: z.number().int().min(0).max(0o777),
+    content: z
+        .string()
+        .refine(isWellFormedUnicode, "profile activation content must be valid Unicode"),
+});
+/**
+ * Compose the shared activation evidence with a producer-owned exact plan.
+ * Candidate materialization uses this factory and adds its stronger plan/file
+ * consistency checks around the resulting schema.
+ */
+export function createAgentProfileActivationEvidenceSchema(profilePlanSchema) {
+    return z.strictObject({
+        profilePlan: profilePlanSchema,
+        files: z.array(agentProfileActivationFileEvidenceSchema),
+        digest: sha256DigestSchema,
+    });
+}

package/dist/agent-profile-canonical.d.ts

@@ -0,0 +1,12 @@
+import type { AgentCandidateJsonValue } from "./agent-candidate.js";
+/**
+ * Normalize profile-shaped data into the canonical JSON domain used for public
+ * profile identity. Undefined object entries are omitted; unsupported values,
+ * sparse arrays, and cycles are rejected with their profile path.
+ *
+ * This module is intentionally internal. Public callers should use the
+ * profile-level operations that own validation, identity, or diff semantics.
+ */
+export declare function canonicalAgentProfileValue(value: unknown): AgentCandidateJsonValue | undefined;
+/** Canonical serialization after applying AgentProfile normalization rules. */
+export declare function canonicalAgentProfileJson(value: unknown): string | undefined;

package/dist/agent-profile-canonical.js

@@ -0,0 +1,79 @@
+import { canonicalCandidateJson, isWellFormedUnicode, } from "./agent-candidate-schema-common.js";
+/**
+ * Normalize profile-shaped data into the canonical JSON domain used for public
+ * profile identity. Undefined object entries are omitted; unsupported values,
+ * sparse arrays, and cycles are rejected with their profile path.
+ *
+ * This module is intentionally internal. Public callers should use the
+ * profile-level operations that own validation, identity, or diff semantics.
+ */
+export function canonicalAgentProfileValue(value) {
+    return normalizeAgentProfileValue(value, [], new Set());
+}
+/** Canonical serialization after applying AgentProfile normalization rules. */
+export function canonicalAgentProfileJson(value) {
+    const normalized = canonicalAgentProfileValue(value);
+    return normalized === undefined
+        ? undefined
+        : canonicalCandidateJson(normalized);
+}
+function normalizeAgentProfileValue(value, path, ancestors) {
+    if (value === undefined)
+        return undefined;
+    if (value === null ||
+        typeof value === "boolean" ||
+        typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "number") {
+        if (!Number.isFinite(value)) {
+            throw new Error(`AgentProfile ${renderPath(path)} must be finite`);
+        }
+        return value;
+    }
+    if (typeof value !== "object") {
+        throw new Error(`AgentProfile ${renderPath(path)} is not JSON serializable`);
+    }
+    if (ancestors.has(value)) {
+        throw new Error(`AgentProfile ${renderPath(path)} must be acyclic`);
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (!Array.isArray(value) &&
+        prototype !== Object.prototype &&
+        prototype !== null) {
+        throw new Error(`AgentProfile ${renderPath(path)} must be a plain JSON object`);
+    }
+    const nextAncestors = new Set(ancestors).add(value);
+    if (Array.isArray(value)) {
+        return Array.from({ length: value.length }, (_, index) => {
+            if (!Object.prototype.hasOwnProperty.call(value, index)) {
+                throw new Error(`AgentProfile ${renderPath([...path, index])} cannot be a sparse array hole`);
+            }
+            const entry = value[index];
+            const normalized = normalizeAgentProfileValue(entry, [...path, index], nextAncestors);
+            if (normalized === undefined) {
+                throw new Error(`AgentProfile ${renderPath([...path, index])} cannot be undefined`);
+            }
+            return normalized;
+        });
+    }
+    const material = Object.create(null);
+    for (const [key, entry] of Object.entries(value)) {
+        if (!isWellFormedUnicode(key)) {
+            throw new Error(`AgentProfile ${renderPath(path)} has a record key that is not valid Unicode`);
+        }
+        const normalized = normalizeAgentProfileValue(entry, [...path, key], nextAncestors);
+        if (normalized !== undefined) {
+            Object.defineProperty(material, key, {
+                value: normalized,
+                enumerable: true,
+                configurable: true,
+                writable: true,
+            });
+        }
+    }
+    return material;
+}
+function renderPath(path) {
+    return path.length === 0 ? "root" : path.join(".");
+}

package/dist/agent-profile-improvement-schema.d.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import type { AgentImprovementSurface } from "./agent-candidate.js";
 import type { AgentProfileDiff } from "./profile-diff.js";
 export declare const agentProfileImprovementTaskSchema: z.ZodObject<{
     kind: z.ZodLiteral<"agent-profile-improvement-task">;
@@ -183,11 +184,7 @@ export declare const agentProfileImprovementExecutionRefSchema: z.ZodObject<{
     digest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
     kind: z.ZodLiteral<"agent-profile-improvement-execution-ref">;
 }, z.core.$strict>;
-/**
- * The first product path changes only prompt and skills, but it uses the
- * shared profile-diff language so execution and activation apply identical
- * ordered patches.
- */
+/** One strict canonical profile patch in an ordered measured change. */
 export declare const agentProfileImprovementChangeStepSchema: z.ZodType<AgentProfileDiff, unknown, z.core.$ZodTypeInternals<AgentProfileDiff, unknown>>;
 export declare const agentProfileImprovementChangeSchema: z.ZodTuple<[z.ZodType<AgentProfileDiff, unknown, z.core.$ZodTypeInternals<AgentProfileDiff, unknown>>], z.ZodType<AgentProfileDiff, unknown, z.core.$ZodTypeInternals<AgentProfileDiff, unknown>>>;
 export declare const agentProfileImprovementExperimentSchema: z.ZodObject<{
@@ -1208,4 +1205,4 @@ export declare const agentProfileImprovementMeasuredComparisonSchema: z.ZodObjec
         }, z.core.$strict>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
-export declare function changedProfileImprovementSurfaces(change: readonly AgentProfileDiff[]): string[];
+export declare function changedProfileImprovementSurfaces(change: readonly AgentProfileDiff[]): AgentImprovementSurface[];

package/dist/agent-profile-improvement-schema.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { changedAgentProfileAxes } from "./profile-diff.js";
 import { agentCandidateLineageSchema } from "./agent-candidate-lineage-schema.js";
 import { canonicalCandidateDigest, isCanonicalJsonValue, omitTopLevelDigest, sha256DigestSchema, } from "./agent-candidate-schema-common.js";
 import { refineAgentExecutionWithinLimits } from "./agent-execution-limits.js";
@@ -103,67 +104,48 @@ export const agentProfileImprovementExecutionRefSchema = profileImprovementEvide
     kind: z.literal("agent-profile-improvement-execution-ref"),
 })
     .strict();
-/**
- * The first product path changes only prompt and skills, but it uses the
- * shared profile-diff language so execution and activation apply identical
- * ordered patches.
- */
+/** One strict canonical profile patch in an ordered measured change. */
 export const agentProfileImprovementChangeStepSchema = agentProfileDiffSchema.superRefine((change, ctx) => {
     const changed = changedProfileImprovementSurfaces([change]);
     if (changed.length === 0) {
         ctx.addIssue({
             code: "custom",
-            message: "profile improvement patch must change prompt or skills",
+            message: "profile improvement patch must change the agent profile",
         });
     }
-    const setKeys = Object.keys(change.set ?? {});
-    if (setKeys.some((key) => key !== "prompt" && key !== "resources")) {
-        ctx.addIssue({
-            code: "custom",
-            path: ["set"],
-            message: "profile improvement patches may set only prompt or skill resources",
-        });
-    }
-    const setResourceKeys = Object.keys(change.set?.resources ?? {});
-    if (setResourceKeys.some((key) => key !== "skills")) {
-        ctx.addIssue({
-            code: "custom",
-            path: ["set", "resources"],
-            message: "profile improvement patches may set only skill resources",
-        });
-    }
-    if (change.set?.resources?.skills?.some((skill) => skill.kind !== "inline")) {
-        ctx.addIssue({
-            code: "custom",
-            path: ["set", "resources", "skills"],
-            message: "measured profile skill patches require inline content with exact bytes",
-        });
-    }
-    const removeKeys = Object.keys(change.remove ?? {});
-    if (removeKeys.some((key) => key !== "prompt" && key !== "resources")) {
-        ctx.addIssue({
-            code: "custom",
-            path: ["remove"],
-            message: "profile improvement patches may remove only prompt or skill resources",
-        });
-    }
-    if (change.remove?.resources === true) {
-        ctx.addIssue({
-            code: "custom",
-            path: ["remove", "resources"],
-            message: "profile improvement patches may not remove unrelated resources",
-        });
+    refineInlineProfileImprovementResources(change, ctx);
+});
+function refineInlineProfileImprovementResources(change, ctx) {
+    const resources = change.set?.resources;
+    if (resources === undefined)
+        return;
+    const groups = [
+        ["files", resources.files?.map((file) => file.resource)],
+        ["tools", resources.tools],
+        ["skills", resources.skills],
+        ["agents", resources.agents],
+        ["commands", resources.commands],
+    ];
+    for (const [name, refs] of groups) {
+        for (const [index, ref] of (refs ?? []).entries()) {
+            if (ref.kind !== "inline") {
+                ctx.addIssue({
+                    code: "custom",
+                    path: ["set", "resources", name, index],
+                    message: "measured profile resource patches require inline content with exact bytes",
+                });
+            }
+        }
     }
-    const removeResources = change.remove?.resources;
-    const removeResourceKeys = Object.keys(typeof removeResources === "object" ? removeResources : {});
-    if (removeResourceKeys.some((key) => key !== "skills")) {
+    if (typeof resources.instructions === "object" &&
+        resources.instructions.kind !== "inline") {
         ctx.addIssue({
             code: "custom",
-            path: ["remove", "resources"],
-            message: "profile improvement patches may remove only skill resources",
+            path: ["set", "resources", "instructions"],
+            message: "measured profile resource patches require inline content with exact bytes",
         });
     }
-});
+}
 export const agentProfileImprovementChangeSchema = z
     .tuple([agentProfileImprovementChangeStepSchema])
     .rest(agentProfileImprovementChangeStepSchema)
@@ -420,16 +402,72 @@ export const agentProfileImprovementMeasuredComparisonSchema = z
 export function changedProfileImprovementSurfaces(change) {
     const surfaces = new Set();
     for (const step of change) {
-        if (step.set?.prompt !== undefined || step.remove?.prompt !== undefined) {
-            surfaces.add("prompt");
+        for (const axis of changedAgentProfileAxes(step)) {
+            if (axis === "prompt" ||
+                axis === "tools" ||
+                axis === "mcp" ||
+                axis === "hooks" ||
+                axis === "subagents") {
+                surfaces.add(axis);
+            }
+            else if (axis === "resources") {
+                const resources = changedResourceSurfaces(step);
+                for (const surface of resources.granular)
+                    surfaces.add(surface);
+                if (resources.other)
+                    surfaces.add("agent-profile");
+            }
+            else {
+                surfaces.add("agent-profile");
+            }
         }
-        if (step.set?.resources?.skills !== undefined ||
-            (typeof step.remove?.resources === "object" &&
-                step.remove.resources.skills !== undefined)) {
-            surfaces.add("skills");
+    }
+    const canonicalOrder = [
+        "prompt",
+        "skills",
+        "tools",
+        "mcp",
+        "hooks",
+        "subagents",
+        "agent-profile",
+    ];
+    return canonicalOrder.filter((surface) => surfaces.has(surface));
+}
+function changedResourceSurfaces(change) {
+    const granular = new Set();
+    let other = false;
+    const setResources = change.set?.resources;
+    if (setResources !== undefined) {
+        const keys = Object.keys(setResources);
+        for (const key of keys) {
+            if (key === "skills" || key === "tools")
+                granular.add(key);
+            else if (key === "agents")
+                granular.add("subagents");
+            else
+                other = true;
+        }
+        other ||= keys.length === 0;
+    }
+    const removeResources = change.remove?.resources;
+    if (removeResources === true) {
+        granular.add("skills");
+        granular.add("tools");
+        granular.add("subagents");
+        other = true;
+    }
+    else if (removeResources !== undefined) {
+        const entries = Object.entries(removeResources).filter(([, value]) => Array.isArray(value) ? value.length > 0 : value === true);
+        for (const [key] of entries) {
+            if (key === "skills" || key === "tools")
+                granular.add(key);
+            else if (key === "agents")
+                granular.add("subagents");
+            else
+                other = true;
         }
     }
-    return [...surfaces].sort();
+    return { granular, other };
 }
 function refineProfileImprovementComparison(comparison, ctx) {
     const { suite, tasks } = comparison.experiment.benchmark;

package/dist/agent-profile-improvement.d.ts

@@ -52,9 +52,9 @@ export interface AgentProfileImprovementExecutionRef extends AgentProfileImprove
  * Ordered portable profile patches retained for review and activation.
  *
  * Applying the steps in order matters: a full resource replacement is a reset
- * followed by a replacement step. Prompt and inline skill content can be
- * sensitive, so the product that persists this value owns access control and
- * redaction.
+ * followed by a replacement step. Complete profile diffs can contain sensitive
+ * host-owned configuration, so the product that persists this value owns access
+ * control and redaction.
  */
 export type AgentProfileImprovementChange = [AgentProfileDiff, ...AgentProfileDiff[]];
 /** A measured comparison of two states of one host-owned agent profile. */

package/dist/agent-profile-materialization.d.ts

@@ -0,0 +1,34 @@
+import type { AgentProfile } from "./agent-profile.js";
+/**
+ * The 29 canonical AgentProfile leaves that can affect one execution.
+ *
+ * Compound parents such as `model`, `prompt`, and `resources` are deliberately
+ * absent. A producer must report the exact requested leaf instead of claiming
+ * a parent while silently dropping one of its children.
+ */
+export declare const AGENT_PROFILE_MATERIALIZATION_AXES: readonly ["name", "description", "version", "tags", "systemPrompt", "instructions", "modelDefault", "modelSmall", "modelProvider", "modelReasoningEffort", "modelMetadata", "harness", "permissions", "tools", "mcp", "connections", "subagents", "files", "resourceTools", "skills", "resourceAgents", "commands", "resourceInstructions", "resourceFailOnError", "hooks", "modes", "confidential", "metadata", "extensions"];
+/** One exact leaf of the public AgentProfile contract. */
+export type AgentProfileMaterializationAxis = (typeof AGENT_PROFILE_MATERIALIZATION_AXES)[number];
+/** Compatibility name used by runtimes that distinguish canonical axes. */
+export type CanonicalAgentProfileMaterializationAxis = AgentProfileMaterializationAxis;
+/** One requested profile leaf and its canonical RFC 6901 JSON Pointer. */
+export interface AgentProfileMaterializationRequest {
+    axis: AgentProfileMaterializationAxis;
+    path: string;
+}
+/**
+ * Return every canonical profile leaf that contains a meaningful request.
+ * Every explicit value is a request, including empty strings, empty
+ * collections, `null`, `false`, and `0`. Only an absent/undefined leaf is
+ * omitted.
+ */
+export declare function profileMaterializationAxes(profile: AgentProfile): readonly AgentProfileMaterializationAxis[];
+/**
+ * Expand requested axes into exact JSON Pointer paths.
+ *
+ * Compound maps and arrays produce one row per explicit scalar leaf. An empty
+ * compound value produces its axis-root path. This prevents an executor from
+ * acknowledging one tool, server, resource, or instruction while claiming the
+ * whole axis, without losing an explicit request to clear that axis.
+ */
+export declare function profileMaterializationRequests(profile: AgentProfile): readonly AgentProfileMaterializationRequest[];

package/dist/agent-profile-materialization.js

@@ -0,0 +1,243 @@
+/**
+ * The 29 canonical AgentProfile leaves that can affect one execution.
+ *
+ * Compound parents such as `model`, `prompt`, and `resources` are deliberately
+ * absent. A producer must report the exact requested leaf instead of claiming
+ * a parent while silently dropping one of its children.
+ */
+export const AGENT_PROFILE_MATERIALIZATION_AXES = [
+    "name",
+    "description",
+    "version",
+    "tags",
+    "systemPrompt",
+    "instructions",
+    "modelDefault",
+    "modelSmall",
+    "modelProvider",
+    "modelReasoningEffort",
+    "modelMetadata",
+    "harness",
+    "permissions",
+    "tools",
+    "mcp",
+    "connections",
+    "subagents",
+    "files",
+    "resourceTools",
+    "skills",
+    "resourceAgents",
+    "commands",
+    "resourceInstructions",
+    "resourceFailOnError",
+    "hooks",
+    "modes",
+    "confidential",
+    "metadata",
+    "extensions",
+];
+const profileProperties = [
+    "prompt",
+    "model",
+    "harness",
+    "permissions",
+    "tools",
+    "mcp",
+    "connections",
+    "subagents",
+    "resources",
+    "hooks",
+    "modes",
+    "confidential",
+    "metadata",
+    "extensions",
+];
+const profilePropertiesAreExhaustive = true;
+void profilePropertiesAreExhaustive;
+const AXIS_DESCRIPTORS = [
+    { axis: "name", rootPath: "/name", value: (profile) => profile.name },
+    {
+        axis: "description",
+        rootPath: "/description",
+        value: (profile) => profile.description,
+    },
+    { axis: "version", rootPath: "/version", value: (profile) => profile.version },
+    { axis: "tags", rootPath: "/tags", value: (profile) => profile.tags },
+    {
+        axis: "systemPrompt",
+        rootPath: "/prompt/systemPrompt",
+        value: (profile) => profile.prompt?.systemPrompt,
+    },
+    {
+        axis: "instructions",
+        rootPath: "/prompt/instructions",
+        value: (profile) => profile.prompt?.instructions,
+    },
+    {
+        axis: "modelDefault",
+        rootPath: "/model/default",
+        value: (profile) => profile.model?.default,
+    },
+    {
+        axis: "modelSmall",
+        rootPath: "/model/small",
+        value: (profile) => profile.model?.small,
+    },
+    {
+        axis: "modelProvider",
+        rootPath: "/model/provider",
+        value: (profile) => profile.model?.provider,
+    },
+    {
+        axis: "modelReasoningEffort",
+        rootPath: "/model/reasoningEffort",
+        value: (profile) => profile.model?.reasoningEffort,
+    },
+    {
+        axis: "modelMetadata",
+        rootPath: "/model/metadata",
+        value: (profile) => profile.model?.metadata,
+    },
+    { axis: "harness", rootPath: "/harness", value: (profile) => profile.harness },
+    {
+        axis: "permissions",
+        rootPath: "/permissions",
+        value: (profile) => profile.permissions,
+    },
+    { axis: "tools", rootPath: "/tools", value: (profile) => profile.tools },
+    { axis: "mcp", rootPath: "/mcp", value: (profile) => profile.mcp },
+    {
+        axis: "connections",
+        rootPath: "/connections",
+        value: (profile) => profile.connections,
+    },
+    {
+        axis: "subagents",
+        rootPath: "/subagents",
+        value: (profile) => profile.subagents,
+    },
+    {
+        axis: "files",
+        rootPath: "/resources/files",
+        value: (profile) => profile.resources?.files,
+    },
+    {
+        axis: "resourceTools",
+        rootPath: "/resources/tools",
+        value: (profile) => profile.resources?.tools,
+    },
+    {
+        axis: "skills",
+        rootPath: "/resources/skills",
+        value: (profile) => profile.resources?.skills,
+    },
+    {
+        axis: "resourceAgents",
+        rootPath: "/resources/agents",
+        value: (profile) => profile.resources?.agents,
+    },
+    {
+        axis: "commands",
+        rootPath: "/resources/commands",
+        value: (profile) => profile.resources?.commands,
+    },
+    {
+        axis: "resourceInstructions",
+        rootPath: "/resources/instructions",
+        value: (profile) => profile.resources?.instructions,
+    },
+    {
+        axis: "resourceFailOnError",
+        rootPath: "/resources/failOnError",
+        value: (profile) => profile.resources?.failOnError,
+    },
+    { axis: "hooks", rootPath: "/hooks", value: (profile) => profile.hooks },
+    { axis: "modes", rootPath: "/modes", value: (profile) => profile.modes },
+    {
+        axis: "confidential",
+        rootPath: "/confidential",
+        value: (profile) => profile.confidential,
+    },
+    {
+        axis: "metadata",
+        rootPath: "/metadata",
+        value: (profile) => profile.metadata,
+    },
+    {
+        axis: "extensions",
+        rootPath: "/extensions",
+        value: (profile) => profile.extensions,
+    },
+];
+const axisDescriptorsAreExhaustive = true;
+void axisDescriptorsAreExhaustive;
+/**
+ * Return every canonical profile leaf that contains a meaningful request.
+ * Every explicit value is a request, including empty strings, empty
+ * collections, `null`, `false`, and `0`. Only an absent/undefined leaf is
+ * omitted.
+ */
+export function profileMaterializationAxes(profile) {
+    const axes = [];
+    for (const descriptor of AXIS_DESCRIPTORS) {
+        if (descriptor.value(profile) !== undefined) {
+            axes.push(descriptor.axis);
+        }
+    }
+    return axes;
+}
+/**
+ * Expand requested axes into exact JSON Pointer paths.
+ *
+ * Compound maps and arrays produce one row per explicit scalar leaf. An empty
+ * compound value produces its axis-root path. This prevents an executor from
+ * acknowledging one tool, server, resource, or instruction while claiming the
+ * whole axis, without losing an explicit request to clear that axis.
+ */
+export function profileMaterializationRequests(profile) {
+    const requests = [];
+    for (const descriptor of AXIS_DESCRIPTORS) {
+        const paths = materializationValuePaths(descriptor.value(profile), descriptor.rootPath);
+        for (const path of paths) {
+            requests.push({ axis: descriptor.axis, path });
+        }
+    }
+    return requests;
+}
+function materializationValuePaths(root, rootPath) {
+    const paths = [];
+    visitMaterializationValue(root, rootPath, [], paths);
+    return paths;
+}
+function visitMaterializationValue(value, path, ancestors, paths) {
+    if (value === undefined)
+        return false;
+    if (value === null || typeof value !== "object") {
+        paths.push(path);
+        return true;
+    }
+    if (ancestors.includes(value)) {
+        paths.push(path);
+        return true;
+    }
+    const nextAncestors = [...ancestors, value];
+    const entries = Array.isArray(value)
+        ? Array.from({ length: value.length }, (_, index) => [
+            String(index),
+            Object.prototype.hasOwnProperty.call(value, index)
+                ? value[index]
+                : undefined,
+        ])
+        : Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
+    let childRequested = false;
+    for (const [key, child] of entries) {
+        childRequested =
+            visitMaterializationValue(child, `${path}/${escapeJsonPointerSegment(key)}`, nextAncestors, paths) || childRequested;
+    }
+    if (!childRequested)
+        paths.push(path);
+    return true;
+}
+function escapeJsonPointerSegment(value) {
+    return value.replace(/~/g, "~0").replace(/\//g, "~1");
+}