@nylorun/harness 0.5.0-beta.1

package/dist/step/run.js

@@ -0,0 +1,127 @@
+import { normalizeCandidate } from "../model-normalize.js";
+import { HarnessError, isHarnessError } from "../errors.js";
+import { copyJson } from "../utils/immutable.js";
+import { runMiddleware } from "./compose.js";
+import { ContextDraft } from "./context-draft.js";
+import { StepContext } from "./step-context.js";
+import { projectModelCall } from "./project.js";
+import { resolveModelRequest } from "./resolve.js";
+import { sealStep } from "./seal.js";
+import { ModelConfigurationDraft } from "./model-configuration.js";
+export async function runStep(input) {
+    const stepInput = Object.freeze({
+        sessionId: input.sessionId,
+        turnId: input.turnId,
+        stepId: input.stepId,
+        turnNumber: input.turnNumber,
+        stepNumber: input.stepNumber,
+        session: input.session,
+        arrivals: Object.freeze([...input.arrivals]),
+        toolResults: Object.freeze([...input.toolResults]),
+        transcript: Object.freeze([...input.state.transcript]),
+    });
+    const configuration = new ModelConfigurationDraft(input.agent.adapters, input.agent.directive);
+    const runtimeContext = new ContextDraft(input.session.context);
+    const context = new StepContext(stepInput, input.observe, configuration, runtimeContext);
+    input.observe(() => ({
+        type: "step.started",
+        turnId: input.turnId,
+        stepId: input.stepId,
+        turnNumber: input.turnNumber,
+        stepNumber: input.stepNumber,
+        attributes: snapshotStepStart(stepInput),
+    }));
+    await runMiddleware(input.agent.middleware, context, async () => {
+        if (context.currentTripwire)
+            return context.tripwire(context.currentTripwire);
+        try {
+            context.sealConfiguration(configuration.snapshot());
+            context.sealContext(runtimeContext.snapshot());
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return context.tripwire({
+                code: isHarnessError(error) ? error.code : "configuration.invalid",
+                message,
+            });
+        }
+        const request = resolveModelRequest({
+            context,
+            arrivals: input.arrivals,
+            toolResults: input.toolResults,
+        });
+        const call = projectModelCall(request);
+        input.observe(() => ({
+            type: "model.requested",
+            turnId: input.turnId,
+            stepId: input.stepId,
+            ...(request.model?.id === undefined ? {} : { requestedModelId: request.model.id }),
+            attributes: Object.freeze({
+                call,
+                configuration: snapshotConfiguration(request.configuration),
+                context: copyJson(request.context),
+            }),
+        }));
+        try {
+            const minted = context.mintFromModel(normalizeCandidate(await input.agent.invoke(call, {
+                request,
+                signal: input.signal,
+            })));
+            if (input.signal.aborted)
+                throw input.signal.reason;
+            const candidate = context.currentCandidate;
+            if (!candidate)
+                throw new HarnessError("model.candidate-missing", "Model candidate missing after mint");
+            input.observe(() => ({
+                type: "model.completed",
+                turnId: input.turnId,
+                stepId: input.stepId,
+                ...(request.model?.id === undefined ? {} : { requestedModelId: request.model.id }),
+                attributes: candidate,
+            }));
+            return minted;
+        }
+        catch (error) {
+            if (input.signal.aborted)
+                throw input.signal.reason;
+            return context.tripwire({
+                code: isHarnessError(error) ? error.code : "model.failed",
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }, input.observe);
+    const output = sealStep(context);
+    const candidate = output.kind === "tools" ? output.plan.candidate : context.currentCandidate;
+    return Object.freeze({ stepId: input.stepId, ...(candidate ? { candidate } : {}), output });
+}
+function snapshotStepStart(input) {
+    const session = Object.freeze({
+        ...(input.session.userId === undefined ? {} : { userId: input.session.userId }),
+        ...(input.session.context === undefined ? {} : { context: copyJson(input.session.context) }),
+    });
+    return Object.freeze({
+        ...(Object.keys(session).length === 0 ? {} : { session }),
+        arrivals: copyJson(input.arrivals),
+        toolResults: copyJson(input.toolResults),
+        transcript: input.transcript,
+    });
+}
+function snapshotConfiguration(configuration) {
+    return Object.freeze({
+        version: configuration.version,
+        ...(configuration.model === undefined ? {} : { model: copyJson(configuration.model) }),
+        instructions: copyJson(configuration.instructions),
+        tools: snapshotTools(configuration.tools),
+        toolContracts: copyJson(configuration.toolContracts),
+        contributors: copyJson(configuration.contributors),
+        digests: copyJson(configuration.digests),
+    });
+}
+function snapshotTools(tools) {
+    return Object.freeze(tools.map((tool) => Object.freeze({
+        name: tool.name,
+        ...(tool.description === undefined ? {} : { description: tool.description }),
+        executeWith: tool.executeWith,
+        parameters: Object.freeze({ jsonSchema: copyJson(tool.parameters.jsonSchema) }),
+    })));
+}

package/dist/step/seal.d.ts

@@ -0,0 +1,31 @@
+import type { ModelCandidate } from "../types/model.js";
+import type { Tripwire } from "../types/shared.js";
+import type { RequiredInteraction, SealedToolCall, ToolResult } from "../types/tool.js";
+import type { StepContext } from "./step-context.js";
+export interface ExecutablePlanEntry {
+    readonly call: SealedToolCall;
+    readonly invocationId: string;
+    readonly interaction?: RequiredInteraction;
+    readonly preflight?: "sandbox" | "validation";
+}
+export interface InternalToolPlan {
+    readonly candidate: ModelCandidate;
+    readonly order: readonly {
+        readonly callId: string;
+        readonly toolName: string;
+    }[];
+    readonly executable: readonly ExecutablePlanEntry[];
+    readonly immediateResults: readonly ToolResult[];
+}
+export type SealedStepOutput = {
+    readonly kind: "tripwire";
+    readonly tripwire: Tripwire;
+} | {
+    readonly kind: "final";
+    readonly output: string;
+} | {
+    readonly kind: "tools";
+    readonly plan: InternalToolPlan;
+};
+/** Converts the reviewed canonical candidate into either a final response or an executable tool plan. */
+export declare function sealStep(context: StepContext): SealedStepOutput;

package/dist/step/seal.js

@@ -0,0 +1,108 @@
+import { textFromOutput } from "../model-normalize.js";
+import { createId } from "../utils/ids.js";
+import { HarnessError, isHarnessError } from "../errors.js";
+import { assertJson, copyJson } from "../utils/immutable.js";
+const failed = (callId, toolName, code, message) => Object.freeze({ kind: "failed", callId, toolName, code, message });
+/** Converts the reviewed canonical candidate into either a final response or an executable tool plan. */
+export function sealStep(context) {
+    if (context.currentTripwire)
+        return Object.freeze({ kind: "tripwire", tripwire: context.currentTripwire });
+    const calls = context.canonicalCalls();
+    if (!calls.length)
+        return Object.freeze({
+            kind: "final",
+            output: textFromOutput(context.currentCandidate?.output ?? []),
+        });
+    const catalog = context.catalogByName;
+    const sealed = calls.map((call) => sealCall(context, catalog, call));
+    const canonicalCandidate = context.currentCandidate ?? Object.freeze({ output: Object.freeze([]) });
+    return Object.freeze({
+        kind: "tools",
+        plan: Object.freeze({
+            candidate: canonicalCandidate,
+            order: Object.freeze(sealed.map((item) => item.order)),
+            executable: Object.freeze(sealed.flatMap((item) => (item.executable ? [item.executable] : []))),
+            immediateResults: Object.freeze(sealed.flatMap((item) => (item.immediate ? [item.immediate] : []))),
+        }),
+    });
+}
+function sealCall(context, catalog, candidate) {
+    const order = Object.freeze({ callId: candidate.id, toolName: candidate.name });
+    const canonical = Object.freeze({
+        id: candidate.id,
+        name: candidate.name,
+        args: candidate.args,
+    });
+    if (candidate.missingId)
+        return {
+            order,
+            canonical,
+            immediate: failed(candidate.id, candidate.name, "tool.invalid-call-id", "Tool call id must not be empty"),
+        };
+    if (candidate.duplicateId)
+        return {
+            order,
+            canonical,
+            immediate: failed(candidate.id, candidate.name, "tool.duplicate-call-id", `Duplicate Tool call id '${candidate.duplicateId}'`),
+        };
+    const tool = catalog.get(candidate.name);
+    if (!tool)
+        return {
+            order,
+            canonical,
+            immediate: failed(candidate.id, candidate.name, "tool.unknown", `Unknown Tool '${candidate.name}'`),
+        };
+    const args = validatedArguments(tool, candidate);
+    if (isHarnessError(args))
+        return {
+            order,
+            canonical,
+            immediate: failed(candidate.id, candidate.name, args.code, args.message),
+        };
+    const denial = context.denialFor(candidate.id);
+    if (denial)
+        return {
+            order,
+            canonical,
+            immediate: Object.freeze({
+                kind: "denied",
+                callId: candidate.id,
+                toolName: candidate.name,
+                reason: denial,
+            }),
+        };
+    const requested = context.interactionFor(candidate.id);
+    const interaction = requested
+        ? Object.freeze({ ...requested, id: requested.id ?? createId("interaction") })
+        : undefined;
+    const preflight = context.preflightFor(candidate.id);
+    return {
+        order,
+        canonical,
+        executable: Object.freeze({
+            call: Object.freeze({
+                callId: candidate.id,
+                toolName: candidate.name,
+                args,
+                executeWith: tool.executeWith,
+            }),
+            invocationId: createId("invocation"),
+            ...(interaction ? { interaction } : {}),
+            ...(preflight ? { preflight } : {}),
+        }),
+    };
+}
+function validatedArguments(tool, candidate) {
+    const validation = tool.parameters.validate(candidate.args);
+    if (!validation.ok)
+        return new HarnessError("tool.invalid-arguments", validation.issues.join("; "));
+    try {
+        assertJson(validation.value, `arguments for '${candidate.name}'`);
+        return copyJson(validation.value);
+    }
+    catch (error) {
+        return isHarnessError(error)
+            ? error
+            : new HarnessError("tool.invalid-arguments", String(error), { cause: error });
+    }
+}

package/dist/step/slot-assembly.d.ts

@@ -0,0 +1,39 @@
+import { type HarnessErrorCode } from "../errors.js";
+export interface SlotOwner {
+    readonly middlewareId: string;
+    readonly middlewareOrder: number;
+    readonly slot: string;
+    readonly order: number;
+}
+export interface SlotDeclaration<Value> {
+    readonly owner: SlotOwner;
+    readonly value: Value;
+    readonly reason?: string;
+}
+/**
+ * Shared per-step slot store. It has no session lifetime: declarations are discarded with the
+ * draft that owns this instance. Configuration and context supply their typed values and snapshot
+ * them after this assembler has applied ownership, replacement, and canonical ordering.
+ */
+export declare class SlotDraft<Value> {
+    #private;
+    set(input: {
+        readonly middlewareId: string;
+        readonly middlewareOrder: number;
+        readonly slot: string;
+        readonly value: Value;
+        readonly order?: number;
+        readonly reason?: string;
+        readonly invalidSlot: HarnessErrorCode;
+        readonly invalidOrder: HarnessErrorCode;
+        readonly invalidReason: HarnessErrorCode;
+        readonly label: string;
+    }): void;
+    values(): readonly SlotDeclaration<Value>[];
+}
+export declare function slotOwner(middlewareId: string, middlewareOrder: number, slot: string): SlotOwner;
+export declare function slotKey(value: SlotOwner): string;
+export declare function checkedSlot(value: string, code: HarnessErrorCode, label: string): void;
+export declare function checkedReason(value: string, code: HarnessErrorCode, label: string): string;
+export declare function withOrder(owner: SlotOwner, requested: number | undefined, previousOrder: number | undefined, code: HarnessErrorCode, label: string): SlotOwner;
+export declare function compareSlotOwners(left: SlotOwner, right: SlotOwner): number;

package/dist/step/slot-assembly.js

@@ -0,0 +1,52 @@
+import { HarnessError } from "../errors.js";
+/**
+ * Shared per-step slot store. It has no session lifetime: declarations are discarded with the
+ * draft that owns this instance. Configuration and context supply their typed values and snapshot
+ * them after this assembler has applied ownership, replacement, and canonical ordering.
+ */
+export class SlotDraft {
+    #slots = new Map();
+    set(input) {
+        checkedSlot(input.slot, input.invalidSlot, input.label);
+        const base = slotOwner(input.middlewareId, input.middlewareOrder, input.slot);
+        const key = slotKey(base);
+        const prior = this.#slots.get(key);
+        const owner = withOrder(base, input.order, prior?.owner.order, input.invalidOrder, input.label);
+        this.#slots.set(key, Object.freeze({
+            owner,
+            value: input.value,
+            ...(input.reason === undefined
+                ? {}
+                : { reason: checkedReason(input.reason, input.invalidReason, input.label) }),
+        }));
+    }
+    values() {
+        return Object.freeze([...this.#slots.values()].sort((left, right) => compareSlotOwners(left.owner, right.owner)));
+    }
+}
+export function slotOwner(middlewareId, middlewareOrder, slot) {
+    return Object.freeze({ middlewareId, middlewareOrder, slot, order: 0 });
+}
+export function slotKey(value) {
+    return `${value.middlewareId}\u0000${value.slot}`;
+}
+export function checkedSlot(value, code, label) {
+    if (typeof value !== "string" || value.length === 0)
+        throw new HarnessError(code, `${label} slot must be a non-empty string`);
+}
+export function checkedReason(value, code, label) {
+    if (typeof value !== "string" || value.length === 0)
+        throw new HarnessError(code, `${label} mutation reason must be a non-empty string`);
+    return value;
+}
+export function withOrder(owner, requested, previousOrder, code, label) {
+    const order = requested ?? previousOrder ?? 0;
+    if (!Number.isFinite(order))
+        throw new HarnessError(code, `${label} order must be a finite number`);
+    return Object.freeze({ ...owner, order });
+}
+export function compareSlotOwners(left, right) {
+    return (left.order - right.order ||
+        left.middlewareOrder - right.middlewareOrder ||
+        left.slot.localeCompare(right.slot));
+}

package/dist/step/step-context.d.ts

@@ -0,0 +1,36 @@
+import type { ContextSnapshot, ModelCandidate, ModelDirective, ModelConfigurationSnapshot } from "../types/model.js";
+import type { StepInput, StepRequest, StepResponse } from "../types/middleware.js";
+import type { Tripwire } from "../types/shared.js";
+import type { ObserveEmit } from "../utils/observe.js";
+import type { BoundToolDefinition, Interaction } from "../types/tool.js";
+import { type CanonicalCall } from "./canonicalize.js";
+import { ContextDraft } from "./context-draft.js";
+import { ModelConfigurationDraft } from "./model-configuration.js";
+export declare function isBrandedResponse(value: unknown): value is StepResponse;
+/** Mutable Step state. Middleware receives leased request views and one branded response. */
+export declare class StepContext {
+    #private;
+    readonly input: Readonly<StepInput>;
+    constructor(input: Readonly<StepInput>, observe: ObserveEmit, configuration: ModelConfigurationDraft, context: ContextDraft);
+    get currentTripwire(): Tripwire | undefined;
+    get currentCandidate(): Readonly<ModelCandidate> | undefined;
+    get selectedDirective(): ModelDirective | undefined;
+    get instructions(): readonly string[];
+    contextSnapshot(): ContextSnapshot;
+    get offeredTools(): readonly BoundToolDefinition[];
+    get catalogByName(): ReadonlyMap<string, BoundToolDefinition>;
+    configurationSnapshot(): ModelConfigurationSnapshot;
+    sealConfiguration(snapshot: ModelConfigurationSnapshot): void;
+    sealContext(snapshot: ContextSnapshot): void;
+    denialFor(callId: string): string | undefined;
+    interactionFor(callId: string): Interaction | undefined;
+    preflightFor(callId: string): "sandbox" | "validation" | undefined;
+    canonicalCalls(): readonly CanonicalCall[];
+    mintFromModel(candidate: Readonly<ModelCandidate>): StepResponse;
+    tripwire(error: Tripwire): StepResponse;
+    seal(): void;
+    requestFacade(middlewareId: string, middlewareOrder: number): {
+        readonly value: StepRequest;
+        revokeMutators(): void;
+    };
+}

package/dist/step/step-context.js

@@ -0,0 +1,255 @@
+import { HarnessError, isHarnessError } from "../errors.js";
+import { callsFromCanonical, candidateFromCanonical, canonicalizeOutput, identityKey, } from "./canonicalize.js";
+import { normalizeCandidate } from "../model-normalize.js";
+import { ContextDraft } from "./context-draft.js";
+import { ModelConfigurationDraft } from "./model-configuration.js";
+const branded = new WeakSet();
+export function isBrandedResponse(value) {
+    return typeof value === "object" && value !== null && branded.has(value);
+}
+/** Mutable Step state. Middleware receives leased request views and one branded response. */
+export class StepContext {
+    input;
+    #observe;
+    #context;
+    #configuration;
+    #denials = new Map();
+    #interactions = new Map();
+    #preflights = new Map();
+    #identities = new Map();
+    #canonical = Object.freeze([]);
+    #candidate;
+    #tripwire;
+    #response;
+    #sealed = false;
+    #configurationSnapshot;
+    #contextSnapshot;
+    constructor(input, observe, configuration, context) {
+        this.input = input;
+        this.#observe = observe;
+        this.#configuration = configuration;
+        this.#context = context;
+    }
+    get currentTripwire() {
+        return this.#tripwire;
+    }
+    get currentCandidate() {
+        return this.#candidate;
+    }
+    get selectedDirective() {
+        return this.configurationSnapshot().model;
+    }
+    get instructions() {
+        return Object.freeze(this.configurationSnapshot().instructions.map((item) => item.text));
+    }
+    contextSnapshot() {
+        return this.#contextSnapshot ?? this.#context.snapshot();
+    }
+    get offeredTools() {
+        return this.configurationSnapshot().tools;
+    }
+    get catalogByName() {
+        return new Map(this.offeredTools.map((tool) => [tool.name, tool]));
+    }
+    configurationSnapshot() {
+        return this.#configurationSnapshot ?? this.#configuration.snapshot();
+    }
+    sealConfiguration(snapshot) {
+        this.#configurationSnapshot = snapshot;
+    }
+    sealContext(snapshot) {
+        this.#contextSnapshot = snapshot;
+    }
+    denialFor(callId) {
+        return this.#denials.get(callId);
+    }
+    interactionFor(callId) {
+        return this.#interactions.get(callId);
+    }
+    preflightFor(callId) {
+        return this.#preflights.get(callId);
+    }
+    canonicalCalls() {
+        return this.#canonical;
+    }
+    mintFromModel(candidate) {
+        const { output, calls } = canonicalizeOutput(candidate.output);
+        this.#canonical = calls;
+        this.#candidate = candidateFromCanonical(candidate, output);
+        this.#identities.clear();
+        for (const call of calls)
+            this.#identities.set(call.id, identityKey(call.name, call.args));
+        return this.#ensureResponse();
+    }
+    tripwire(error) {
+        this.#tripwire ??= Object.freeze({ ...error });
+        return this.#ensureResponse();
+    }
+    seal() {
+        this.#sealed = true;
+    }
+    requestFacade(middlewareId, middlewareOrder) {
+        let mutatorsActive = true;
+        const mutate = (action) => {
+            if (!mutatorsActive || this.#sealed) {
+                this.#observe({
+                    type: "middleware.lease-violation",
+                    turnId: this.input.turnId,
+                    stepId: this.input.stepId,
+                    middlewareId,
+                    reason: this.#sealed ? "step-sealed" : "mutators-revoked",
+                });
+                throw new HarnessError("middleware.request-mutators-revoked", "Middleware request mutators are no longer active", { details: { middlewareId } });
+            }
+            action();
+        };
+        const mutateConfiguration = (kind, action) => mutate(() => {
+            try {
+                action();
+            }
+            catch (cause) {
+                const message = cause instanceof Error ? cause.message : String(cause);
+                const code = isHarnessError(cause)
+                    ? cause.code
+                    : kind === "tools"
+                        ? "tool.invalid-schema"
+                        : kind === "model"
+                            ? "model.invalid-directive"
+                            : "configuration.invalid-instructions";
+                this.#tripwire ??= Object.freeze({ code, message });
+            }
+        });
+        const mutateContext = (action) => mutate(() => {
+            try {
+                action();
+            }
+            catch (cause) {
+                const message = cause instanceof Error ? cause.message : String(cause);
+                this.#tripwire ??= Object.freeze({
+                    code: isHarnessError(cause) ? cause.code : "context.invalid-item",
+                    message,
+                });
+            }
+        });
+        const value = Object.freeze({
+            sessionId: this.input.sessionId,
+            turnId: this.input.turnId,
+            stepId: this.input.stepId,
+            session: this.input.session,
+            turnNumber: this.input.turnNumber,
+            stepNumber: this.input.stepNumber,
+            arrivals: this.input.arrivals,
+            toolResults: this.input.toolResults,
+            transcript: this.input.transcript,
+            context: Object.freeze({
+                set: (slot, items, options) => mutateContext(() => this.#context.set(middlewareId, middlewareOrder, slot, items, options)),
+            }),
+            configuration: Object.freeze({
+                instructions: Object.freeze({
+                    set: (slot, items, options) => mutateConfiguration("instructions", () => this.#configuration.setInstructions(middlewareId, middlewareOrder, slot, items, options)),
+                }),
+                tools: Object.freeze({
+                    set: (slot, tools, options) => mutateConfiguration("tools", () => this.#configuration.setTools(middlewareId, middlewareOrder, slot, tools, options)),
+                }),
+                model: Object.freeze({
+                    select: (directive, options) => mutateConfiguration("model", () => this.#configuration.select(middlewareId, middlewareOrder, directive, options)),
+                    replace: (directive, options) => mutateConfiguration("model", () => this.#configuration.replace(middlewareId, middlewareOrder, directive, options)),
+                    clear: (options) => mutateConfiguration("model", () => this.#configuration.clear(options)),
+                }),
+            }),
+            tripwire: (error) => {
+                let minted;
+                mutate(() => {
+                    minted = this.tripwire(error);
+                });
+                return minted;
+            },
+        });
+        return Object.freeze({
+            value,
+            revokeMutators: () => {
+                mutatorsActive = false;
+            },
+        });
+    }
+    #ensureResponse() {
+        if (this.#response)
+            return this.#response;
+        const value = Object.freeze({
+            candidate: () => this.currentCandidate,
+            toolCalls: () => callsFromCanonical(this.#canonical),
+            replace: (candidate) => this.#replace(candidate),
+            deny: (callId, reason) => {
+                if (!this.#denials.has(callId))
+                    this.#denials.set(callId, reason);
+            },
+            requireInteraction: (callId, interaction) => {
+                if (!this.#interactions.has(callId))
+                    this.#interactions.set(callId, freezeGraph({ ...interaction }));
+            },
+            requirePreflight: (callId, kind) => {
+                if (!this.#preflights.has(callId))
+                    this.#preflights.set(callId, kind);
+            },
+            tripwire: (error) => {
+                this.#tripwire ??= Object.freeze({ ...error });
+                return value;
+            },
+        });
+        branded.add(value);
+        this.#response = value;
+        return value;
+    }
+    #replace(candidate) {
+        let normalized;
+        try {
+            normalized = normalizeCandidate(candidate);
+        }
+        catch (error) {
+            this.#tripwire ??= Object.freeze({
+                code: isHarnessError(error) ? error.code : "response.invalid-replacement",
+                message: error instanceof Error ? error.message : String(error),
+            });
+            return;
+        }
+        const { output, calls: next } = canonicalizeOutput(normalized.output);
+        for (const call of next) {
+            const original = this.#identities.get(call.id);
+            if (original === undefined) {
+                this.#tripwire ??= Object.freeze({
+                    code: "response.invalid-replacement",
+                    message: `replace() cannot add Tool call '${call.id}'`,
+                });
+                return;
+            }
+            if (original !== identityKey(call.name, call.args)) {
+                this.#tripwire ??= Object.freeze({
+                    code: "response.invalid-replacement",
+                    message: `replace() cannot change identity of Tool call '${call.id}'`,
+                });
+                return;
+            }
+        }
+        const current = this.#candidate;
+        this.#canonical = next;
+        this.#candidate = Object.freeze({
+            output,
+            ...pickSidecar("finishReason", candidate, normalized, current),
+            ...pickSidecar("usage", candidate, normalized, current),
+            ...pickSidecar("evidence", candidate, normalized, current),
+        });
+    }
+}
+function pickSidecar(key, replacement, normalized, current) {
+    const source = Object.hasOwn(replacement, key) ? normalized : current;
+    const value = source?.[key];
+    return value === undefined ? {} : { [key]: value };
+}
+function freezeGraph(value, seen = new WeakSet()) {
+    if (!value || typeof value !== "object" || seen.has(value))
+        return value;
+    seen.add(value);
+    for (const item of Object.values(value))
+        freezeGraph(item, seen);
+    return Object.freeze(value);
+}