@namzu/sdk 36.0.0 → 38.0.0

package/src/tools/memory/search.ts

@@ -14,19 +14,26 @@ function defineSearchMemoryTool(search: SearchMemory): ToolDefinition {
 	return defineTool({
 		name: 'search_memory',
 		description:
-			'Search stored memories by query, tags, or status. Returns titles and summaries only — use read_memory for full content.',
+			'Search active stored memories by relevant words or tags. The built-in store ranks matches in titles, summaries and full content. Returns titles and summaries; use read_memory for evidence. Set status to archived to inspect obsolete records.',
 		inputSchema: z.object({
-			query: z.string().optional().describe('Search query to match against titles and summaries'),
+			query: z.string().optional().describe('Relevant words or identifiers to search'),
 			tags: z.array(z.string()).optional().describe('Filter by tags (all must match)'),
-			limit: z.number().positive().default(10).describe('Maximum results to return'),
+			status: z.enum(['active', 'archived']).default('active'),
+			limit: z
+				.number()
+				.int()
+				.min(1)
+				.max(50)
+				.default(10)
+				.describe('Maximum results to return (1–50)'),
 		}),
 		category: 'analysis',
 		permissions: [],
 		readOnly: true,
 		destructive: false,
 		concurrencySafe: true,
-		async execute({ query, tags, limit }) {
-			const result = await search({ query, tags, limit })
+		async execute({ query, tags, status, limit }) {
+			const result = await search({ query, tags, status, limit })
 
 			if (result.entries.length === 0) {
 				return {

package/src/tools/memory/update.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod'
+import type { MemoryStore } from '../../types/memory/index.js'
+import type { ToolDefinition } from '../../types/tool/index.js'
+import { asMemoryId } from '../../utils/id.js'
+import { defineTool } from '../defineTool.js'
+
+export function buildUpdateMemoryTool(store: MemoryStore): ToolDefinition {
+	return defineTool({
+		name: 'update_memory',
+		description:
+			'Correct an existing memory in place, or archive an obsolete claim so it is no longer recalled. Use the ID from search_memory; current evidence should determine corrections.',
+		inputSchema: z.object({
+			id: z.string().describe('Memory ID to correct or archive'),
+			title: z.string().min(1).optional(),
+			summary: z.string().min(1).optional(),
+			content: z.string().min(1).optional(),
+			tags: z.array(z.string()).optional(),
+			status: z.enum(['active', 'archived']).optional(),
+		}),
+		category: 'custom',
+		permissions: [],
+		readOnly: false,
+		destructive: false,
+		concurrencySafe: true,
+		async execute({ id, ...updates }) {
+			if (Object.values(updates).every((value) => value === undefined)) {
+				return {
+					success: false,
+					output: 'Provide a correction or status to update.',
+					error: 'No memory update supplied',
+				}
+			}
+			const memoryId = asMemoryId(id)
+			// Patch only requested fields in one store operation. A read/merge of
+			// provenance here would overwrite metadata from a concurrent writer.
+			const entry = await store.update(memoryId, updates)
+			if (!entry)
+				return {
+					success: false,
+					output: `Memory ${id} no longer exists.`,
+					error: 'Memory not found',
+				}
+			return {
+				success: true,
+				output: `Memory updated: ${id} — ${entry.title} (${entry.status}).`,
+				data: { id, status: entry.status },
+			}
+		},
+	})
+}

package/src/tools/task/list.ts

@@ -8,7 +8,7 @@ export function buildTaskListTool(taskStore: TaskStore, runId: RunId): ToolDefin
 	return defineTool({
 		name: 'task_list',
 		description:
-			'List all tasks for the current run. Shows subject, status, owner, and unresolved blockers. Use this to review your plan and decide what to work on next.',
+			'List planning items for the current run, not delegated agent invocations. Use agent_task_list, when available, to inspect agent execution. Shows subject, status, owner, and unresolved blockers. Use this to review your plan and decide what to work on next.',
 		inputSchema: z.object({}),
 		category: 'custom',
 		permissions: [],
@@ -46,7 +46,7 @@ export function buildTaskListTool(taskStore: TaskStore, runId: RunId): ToolDefin
 				success: true,
 				output:
 					tasks.length === 0
-						? 'No tasks yet.'
+						? 'No planning tasks yet. This list does not report delegated agent status; use agent_task_list when available.'
 						: `${stats.total} tasks: ${stats.completed} completed, ${stats.in_progress} in progress, ${stats.pending} pending.`,
 				data: { tasks: summary, stats },
 			}

package/src/types/agent/scheduler.ts

@@ -29,6 +29,12 @@ export interface TaskHandle {
 export type SiblingFailurePolicy = 'continue' | 'cancel-siblings'
 
 export interface CreateTaskOptions {
+	/**
+	 * Revalidate host authority at actual admission, including after a capacity wait.
+	 * Queue retries may invoke this more than once; checks must tolerate repeated calls.
+	 */
+	readonly beforeStart?: () => Promise<void>
+
 	/**
 	 * Observe events from this one delegated run when the scheduler can expose
 	 * them.

package/src/types/agent/task.ts

@@ -122,6 +122,7 @@ export interface AgentTask {
 	agentId: string
 	agent: Agent<BaseAgentConfig, BaseAgentResult>
 	childAbortController: AbortController
+	/** While pending admission this is the submitting authority; admitted tasks receive child scope. */
 	context: AgentTaskContext
 	state: AgentTaskState
 	result?: BaseAgentResult
@@ -142,6 +143,12 @@ export interface AgentTask {
  * WorkspaceRef triple atomically on every spawn.
  */
 export interface SendMessageOptions {
+	/**
+	 * Revalidate host authority before admission, including after a capacity wait.
+	 * Queue retries may invoke this more than once; checks must tolerate repeated calls.
+	 */
+	readonly beforeStart?: () => Promise<void>
+
 	/** See {@link import('./scheduler.js').CreateTaskOptions.toolScope}. Deny-only. */
 	readonly toolScope?: { readonly deny: readonly string[] }
 	/** See {@link import('./scheduler.js').CreateTaskOptions.personaOverride}. */
@@ -179,6 +186,12 @@ export interface SendMessageOptions {
 }
 
 export interface AgentManagerConfig {
+	/** Reject a full parent immediately (default), or retain bounded pending task handles. */
+	capacityBehavior?: 'reject' | 'queue'
+
+	/** Maximum tasks awaiting admission across this manager. Defaults to 128. */
+	maxPendingTasks?: number
+
 	maxDepth: number
 
 	evictionMs: number

package/src/types/computer-use/index.ts

@@ -30,6 +30,12 @@ export interface ComputerUseCapabilities {
 	readonly keyboard: boolean
 	readonly cursorPosition: boolean
 	readonly clipboard: boolean
+	/** Exact action subset when known. Refines the broad flags; absent retains their legacy interpretation. */
+	readonly supportedActions?: readonly ComputerUseAction['type'][]
+	/** Supported click buttons; absent leaves button admission to the host. */
+	readonly mouseClickButtons?: readonly MouseButton[]
+	/** Supported drag buttons; absent leaves button admission to the host. */
+	readonly mouseDragButtons?: readonly MouseButton[]
 	/**
 	 * Why every flag above is false, when a host loaded but the desktop did
 	 * not answer — a WSL process with PowerShell and no interactive Windows

package/src/types/errors/catalog.ts

@@ -157,7 +157,7 @@ export const DEFAULT_ERROR_RULES: readonly ErrorCatalogRule[] = [
 		id: 'provider.rate_limit',
 		when: (facts) => facts.code === 'rate_limit' || facts.status === 429,
 		message: 'The provider is rate limiting this run.',
-		hint: 'Automatic retries with backoff have already been exhausted. Lower concurrency, or wait for the quota window to reset before resuming.',
+		hint: 'Respect the provider retry delay when reported. Lower concurrency, or wait for the quota window to reset before resuming.',
 	},
 	{
 		id: 'provider.context_overflow',

package/src/types/hitl/index.ts

@@ -2,7 +2,7 @@ import type { WorkingStateSnapshot } from '../../compaction/wire.js'
 import type { SerializedSpanContext } from '../../telemetry/attributes.js'
 import type { CostInfo, TokenUsage } from '../common/index.js'
 import type { CheckpointId, PlanId, RunId } from '../ids/index.js'
-import type { Message } from '../message/index.js'
+import type { Message, UserMessage } from '../message/index.js'
 import type { PlanStatus } from '../plan/index.js'
 import type { TokenBudgetBinding } from '../run/token-budget-store.js'
 
@@ -212,6 +212,16 @@ export interface IterationCheckpoint {
 	runId: RunId
 	iteration: number
 	messages: Message[]
+	/**
+	 * Current operator/goal/steering text and provenance, independent of
+	 * compacted history. Attachments are not duplicated here. Older
+	 * checkpoints omit this field and use surviving history on resume.
+	 */
+	latestUserMessage?: UserMessage
+	/** Structured host-review rejections consumed at this checkpoint, independent of compacted messages. */
+	structuredReviewAttempts?: number
+	/** Native structured-output corrections consumed independently of message history. */
+	nativeStructuredAttempts?: number
 	tokenUsage: TokenUsage
 	costInfo: CostInfo
 	/**

package/src/types/memory/index.ts

@@ -31,11 +31,19 @@ export interface MemoryContent {
 	readonly metadata?: Record<string, unknown>
 }
 
+/** Metadata and body observed together at one store read boundary. */
+export interface MemoryRecord {
+	readonly entry: MemoryIndexEntry
+	readonly content: MemoryContent
+}
+
 export interface MemorySearchParams {
 	readonly query?: string
 	readonly tags?: string[]
 	readonly status?: MemoryStatus
 	readonly limit?: number
+	/** Match at least one exact normalized word token before limiting results. Empty means no constraint. */
+	readonly requiredIdentifiers?: readonly string[]
 }
 
 export interface MemorySearchResult {
@@ -52,10 +60,17 @@ export interface CreateMemoryParams {
 	readonly metadata?: Record<string, unknown>
 }
 
+/** Change a memory's content or explicitly archive/reactivate it. */
+export interface UpdateMemoryParams extends Partial<CreateMemoryParams> {
+	readonly status?: MemoryStatus
+}
+
 export interface MemoryStore {
 	create(params: CreateMemoryParams): Promise<{ entry: MemoryIndexEntry; content: MemoryContent }>
 	get(id: MemoryId): Promise<MemoryContent | undefined>
-	update(id: MemoryId, updates: Partial<CreateMemoryParams>): Promise<MemoryIndexEntry | undefined>
+	/** Current metadata/body snapshot; supports rechecking status after search. */
+	getRecord?(id: MemoryId): Promise<MemoryRecord | undefined>
+	update(id: MemoryId, updates: UpdateMemoryParams): Promise<MemoryIndexEntry | undefined>
 	delete(id: MemoryId): Promise<boolean>
 	list(params?: MemorySearchParams): Promise<MemorySearchResult>
 }

package/src/types/plugin/index.ts

@@ -8,6 +8,10 @@ import {
 	MAX_TOOLS_PER_PLUGIN,
 	PLUGIN_NAME_MAX_LENGTH,
 } from '../../constants/plugin/index.js'
+import type {
+	RequestContextChange,
+	RequestContextSnapshot,
+} from '../../runtime/query/request-context.js'
 import type { PluginId, RunId, SessionId } from '../ids/index.js'
 import type { Message, ToolResultContent } from '../message/index.js'
 import type { CancelCause } from '../run/cancel-cause.js'
@@ -142,6 +146,12 @@ export function assertPluginHookEvent(event: PluginHookEvent): void {
  * contract by accident.
  */
 export interface PluginModelRequest {
+	/** SDK provider-input content inventory; excludes adapter/server-private transformations. */
+	readonly context?: {
+		readonly snapshot: RequestContextSnapshot
+		/** Compared with the preceding pre_llm_call in this run; absent on the first. */
+		readonly change?: RequestContextChange
+	}
 	readonly model: string
 	readonly messages: readonly Message[]
 	/** Names only. A hook auditing tool exposure needs the set, not the schemas. */

package/src/types/project/entity.ts

@@ -18,6 +18,7 @@ import type { ProjectId } from '../session/ids.js'
  */
 export interface ProjectConfig {
 	maxDelegationDepth: number
+	/** Maximum pending or active direct delegations; completed history does not consume capacity. */
 	maxDelegationWidth: number
 	maxInterventionDepth: number
 	sharedMemoryStores?: readonly MemoryStoreRef[]

package/src/types/provider/chat.ts

@@ -34,6 +34,8 @@ export interface ChatCompletionParams {
 	 * calls may omit it; a provider then uses its own id, `model`, and index 0.
 	 */
 	providerRoute?: ProviderRoute
+	/** Opt in to provider-hosted web search. Absent means no hosted search. */
+	webSearch?: { mode: 'cached' | 'live' }
 	tools?: LLMToolSchema[]
 	/**
 	 * Provider hint naming tools whose model-facing JSON Schema should be

package/src/types/provider/config.ts

@@ -121,6 +121,10 @@ export interface MockProviderConfig extends MockScript {
  * degradation is loud instead of silent.
  */
 export interface ProviderCapabilities {
+	/** Explicit provider-hosted web search support; absent means unsupported. */
+	supportsHostedWebSearch?: boolean
+	/** Native JSON Schema response-format mapping. Absent means unsupported. */
+	supportsNativeStructuredOutput?: boolean
 	supportsTools: boolean
 	supportsStreaming: boolean
 	supportsFunctionCalling: boolean

package/src/types/provider/model.ts

@@ -14,6 +14,10 @@ export interface ModelInfo {
 	 * the answer; it must not be read as text-only.
 	 */
 	inputModalities?: readonly ModelInputModality[]
+	/** Exact selectable effort levels for this model and route. Absent means unknown; [] means unsupported. */
+	reasoningEffortLevels?: readonly import('./chat.js').ReasoningEffort[]
+	/** Published default, when established; must belong to reasoningEffortLevels when both are present. */
+	reasoningEffortDefault?: import('./chat.js').ReasoningEffort
 	/**
 	 * Tokens the model's context holds, when the driver knows.
 	 *

package/src/types/provider/stream.ts

@@ -9,6 +9,13 @@ export interface StreamChunk {
 	 */
 	replayState?: unknown
 	delta: {
+		/** Activity executed by the provider, never a local function-call request. */
+		hostedTool?: {
+			id: string
+			name: 'web_search'
+			status: 'running' | 'completed' | 'failed'
+		}
+
 		content?: string
 		toolCalls?: Array<{
 			index: number

package/src/types/run/answer-review.ts

@@ -29,6 +29,8 @@ export type AnswerReview =
 export interface AnswerReviewContext {
 	readonly runId: RunId
 	readonly iteration: number
+	/** Run cancellation; reviewers should forward it to verification operations. */
+	readonly signal?: AbortSignal
 	/** The full history, so a reviewer can see how the answer was reached. */
 	readonly messages: readonly Message[]
 }

package/src/types/run/config.ts

@@ -65,6 +65,8 @@ export interface AgentRunConfig {
 	 * high-effort and silently was not is worse than a startup error.
 	 */
 	effort?: import('../provider/index.js').ReasoningEffort
+	/** Provider-hosted search for this run. Explicit opt-in; no local network permission. */
+	webSearch?: import('../provider/index.js').ChatCompletionParams['webSearch']
 	tokenBudget: number
 	costLimitUsd?: number
 	maxIterations?: number

package/src/types/run/events.ts

@@ -17,6 +17,7 @@ import type { Message } from '../message/index.js'
 import type { PlanStep } from '../plan/index.js'
 import type { PluginHookEvent, PluginHookResult } from '../plugin/index.js'
 import type { TaskStatus } from '../task/index.js'
+import type { ToolResultView } from '../tool/presentation.js'
 import type { CancelCause } from './cancel-cause.js'
 import type { FencingToken } from './checkpoint-store.js'
 import type { Lineage } from './lineage.js'
@@ -101,6 +102,16 @@ interface RunEventEnvelope {
 }
 
 type CoreRunEvent =
+	| {
+			type: 'tool_calls_admitted'
+			runId: RunId
+			kind: 'initialize' | 'batch' | 'nested' | 'retry'
+			/** Newly reserved attempts; zero only for ledger initialization. */
+			count: number
+			/** Cumulative reserved attempts, including abandoned reservations. */
+			used: number
+			limit: number
+	  }
 	| { type: 'run_started'; runId: RunId; systemPrompt?: string }
 	| { type: 'iteration_started'; runId: RunId; iteration: number }
 	/**
@@ -357,6 +368,13 @@ type CoreRunEvent =
 			/** Optional completion in [0,1] when the tool genuinely knows it. */
 			fraction?: number
 	  }
+	/** Provider-executed activity, retained as evidence rather than a local tool request. */
+	| {
+			type: 'hosted_tool'
+			runId: RunId
+			iteration: number
+			tool: NonNullable<import('../provider/index.js').StreamChunk['delta']['hostedTool']>
+	  }
 	/**
 	 * A model call failed transiently and is being retried after a backoff.
 	 *
@@ -416,6 +434,8 @@ type CoreRunEvent =
 	  }
 	| {
 			type: 'tool_completed'
+			/** Bounded result view; omitted when output was overridden or truncated. */
+			presentation?: ToolResultView
 			runId: RunId
 			toolUseId: ToolUseId
 			toolName: string

package/src/types/run/prepare-step.ts

@@ -1,5 +1,5 @@
 import type { RunId } from '../ids/index.js'
-import type { Message } from '../message/index.js'
+import type { Message, UserMessage } from '../message/index.js'
 import type { ToolChoice } from '../provider/chat.js'
 import type { Skill } from '../skills/index.js'
 import type { StepResult } from './step.js'
@@ -21,6 +21,24 @@ export interface PrepareStepContext {
 	readonly stepNumber: number
 	/** Full history as it stands, so a decision can read what happened. */
 	readonly messages: readonly Message[]
+	/**
+	 * Latest operator, goal-round, or steering input accepted by this run,
+	 * retained even when compaction removes it from `messages`. Project
+	 * instructions and task-completion context do not replace operator intent.
+	 */
+	readonly latestUserMessage?: UserMessage
+	/** The run's cancellation signal, for bounded asynchronous preparation. */
+	readonly signal?: AbortSignal
+	/**
+	 * Estimated room for additional step context after existing messages,
+	 * earlier stages' system/skills, and a response reserve. Recomputed for
+	 * each stage and its selected model; not a billing limit or fit guarantee.
+	 * `beforeStep` observes its existing boundary before compaction runs.
+	 */
+	readonly contextBudget?: {
+		readonly remainingTokens: number
+		readonly windowTokens: number
+	}
 	/** Every completed step, in order. */
 	readonly steps: readonly StepResult[]
 

package/src/types/sandbox/index.ts

@@ -310,6 +310,7 @@ export interface Sandbox {
 	listFiles(rootPath: string): Promise<readonly SandboxFileEntry[]>
 	/**
 	 * Lazily enumerate regular files as absolute paths, without following symlinks.
+	 * A regular-file root yields that file if its basename matches the pattern.
 	 * Cancellation and iterator return stop traversal. Exceeding the examined-entry
 	 * budget throws an error with code `ERR_FILE_WALK_LIMIT`; it is not an empty or
 	 * complete listing. Hosts requiring bounded search must refuse an absent method.

package/src/types/structured-output/index.ts

@@ -1,10 +1,10 @@
 import type { z } from 'zod'
 
 /**
- * Configuration for structured output via tool constraint.
+ * Configuration for validated output via tool constraint or native JSON Schema.
  *
  * This configuration allows an agent to produce validated, typed output by
- * presenting the output schema as a special tool that the model must call.
+ * presenting the output schema as a tool by default, or as a native response format.
  */
 export interface StructuredOutputConfig<TSchema extends z.ZodType = z.ZodType> {
 	/**
@@ -13,6 +13,9 @@ export interface StructuredOutputConfig<TSchema extends z.ZodType = z.ZodType> {
 	 */
 	schema: TSchema
 
+	/** Default tool constraint, or native JSON schema on an explicitly capable driver. */
+	mode?: 'tool' | 'native'
+
 	/**
 	 * Turns spent re-prompting when the model answers in prose or fails
 	 * validation. Defaults to {@link DEFAULT_STRUCTURED_OUTPUT_RETRIES}.
@@ -21,6 +24,16 @@ export interface StructuredOutputConfig<TSchema extends z.ZodType = z.ZodType> {
 	 * than iterating against `maxIterations`.
 	 */
 	maxRetries?: number
+
+	/** Review the JSON-decoded result before settlement. Narrow the value before use: serialization may change schema output types. Exceptions fail the run; cancellation is propagated. */
+	review?: (
+		output: unknown,
+		context: import('../run/answer-review.js').AnswerReviewContext,
+	) =>
+		| import('../run/answer-review.js').AnswerReview
+		| Promise<import('../run/answer-review.js').AnswerReview>
+	/** Corrections allowed after host rejection, separate from schema retries. Default 3; zero allows no correction. */
+	maxReviews?: number
 }
 
 /**

package/src/types/tool/index.ts

@@ -14,6 +14,8 @@ import type { ToolPresentation } from './presentation.js'
 
 export interface ToolRegistryRef {
 	searchDeferred(query: string): ToolDefinition[]
+	/** Ranked active matches, when this registry supports active-tool discovery. */
+	searchActive?(query: string): ToolDefinition[]
 	activate(names: string[]): void
 	getAvailability(name: string): ToolAvailability
 }
@@ -633,6 +635,18 @@ export interface ToolDefinition<TInput = unknown> extends ToolPresentation<TInpu
 	isDestructive?(input: TInput): boolean
 	isConcurrencySafe?(input: TInput): boolean
 
+	/**
+	 * Opt-in ordering boundary in a direct model tool-call batch. Earlier
+	 * calls settle before this call starts; later calls wait for this call
+	 * to settle (including failed results). Defaults to false. Independent
+	 * calls between barriers retain their existing concurrency-safe behavior.
+	 * Nested dispatch is owned by its enclosing call, not separately queued;
+	 * mark the enclosing tool as a barrier to isolate its nested operations.
+	 * Deadlines still abandon uncooperative tools: settlement does not prove
+	 * their external effects have stopped, and does not imply success.
+	 */
+	executionBarrier?: boolean
+
 	/**
 	 * Where this tool came from, when it did not come from here.
 	 *
@@ -763,6 +777,8 @@ export interface ToolRegistryContract {
 	suspendAll(): void
 	hasSuspended(): boolean
 	searchDeferred(query: string): ToolDefinition[]
+	/** Ranked active matches, when this registry supports active-tool discovery. */
+	searchActive?(query: string): ToolDefinition[]
 	getCallableTools(toolNames?: string[]): ToolDefinition[]
 
 	/**

package/src/types/tool/presentation.ts

@@ -22,6 +22,8 @@ export type ToolCallView =
 			readonly label: string
 			/** Render this complete authored label without adding the registry name. */
 			readonly presentation?: 'activity'
+			/** Successful observations may be grouped by hosts without discarding output. */
+			readonly activity?: 'exploration'
 			/** A successful result may add no information beyond the completed call row. */
 			readonly visibility?: 'hidden'
 	  }
@@ -32,6 +34,8 @@ export type ToolCallView =
 	 */
 	| {
 			readonly kind: 'diff'
+			/** Optional operation summary, distinct from the file path. */
+			readonly label?: string
 			readonly path?: string
 			readonly before: string
 			readonly after: string

package/src/utils/json-snapshot.ts

@@ -0,0 +1,76 @@
+/** Clone JSON data without invoking getters or silently dropping values. */
+export function cloneJsonValue(value: unknown, freeze: boolean, path = '$'): unknown {
+	const active = new WeakSet<object>()
+	const copies = new WeakMap<object, object>()
+
+	const clone = (candidate: unknown, at: string): unknown => {
+		if (candidate === null || typeof candidate === 'string' || typeof candidate === 'boolean') {
+			return candidate
+		}
+		if (typeof candidate === 'number') {
+			if (!Number.isFinite(candidate) || Object.is(candidate, -0)) {
+				throw new TypeError(`${at} must be a finite JSON number`)
+			}
+			return candidate
+		}
+		if (typeof candidate !== 'object') {
+			throw new TypeError(`${at} must be a JSON value, not ${typeof candidate}`)
+		}
+		if (active.has(candidate)) throw new TypeError(`${at} contains a cycle`)
+		const existing = copies.get(candidate)
+		if (existing) return existing
+
+		active.add(candidate)
+		try {
+			if (Array.isArray(candidate)) {
+				const extra = Reflect.ownKeys(candidate).filter(
+					(key) => key !== 'length' && (typeof key !== 'string' || !/^(0|[1-9]\d*)$/.test(key)),
+				)
+				if (extra.length > 0) throw new TypeError(`${at} has non-JSON array properties`)
+				const result: unknown[] = new Array(candidate.length)
+				copies.set(candidate, result)
+				for (let index = 0; index < candidate.length; index++) {
+					const descriptor = Object.getOwnPropertyDescriptor(candidate, String(index))
+					if (!descriptor) throw new TypeError(`${at}[${index}] is a sparse array hole`)
+					if (!descriptor.enumerable || !('value' in descriptor)) {
+						throw new TypeError(`${at}[${index}] must be an enumerable data property`)
+					}
+					result[index] = clone(descriptor.value, `${at}[${index}]`)
+				}
+				if (freeze) Object.freeze(result)
+				return result
+			}
+
+			const prototype = Object.getPrototypeOf(candidate)
+			if (prototype !== Object.prototype && prototype !== null) {
+				throw new TypeError(`${at} must be a plain JSON object`)
+			}
+			// JSON does not preserve prototypes. Canonicalize both admitted plain
+			// shapes to an ordinary object so a disk checkpoint round-trip compares
+			// equal to a fresh preparation of the same semantic value. Properties
+			// are still defined explicitly, so a literal "__proto__" key remains
+			// data rather than changing this object's prototype.
+			const result: Record<string, unknown> = {}
+			copies.set(candidate, result)
+			for (const key of Reflect.ownKeys(candidate)) {
+				if (typeof key !== 'string') throw new TypeError(`${at} has a symbol property`)
+				const descriptor = Object.getOwnPropertyDescriptor(candidate, key)
+				if (!descriptor?.enumerable || !('value' in descriptor)) {
+					throw new TypeError(`${at}.${key} must be an enumerable data property`)
+				}
+				Object.defineProperty(result, key, {
+					value: clone(descriptor.value, `${at}.${key}`),
+					enumerable: true,
+					writable: !freeze,
+					configurable: !freeze,
+				})
+			}
+			if (freeze) Object.freeze(result)
+			return result
+		} finally {
+			active.delete(candidate)
+		}
+	}
+
+	return clone(value, path)
+}