dsh-ptc-plus 0.3.2 → 0.4.2

package/internal/cordis-tools-owner.js

@@ -7,6 +7,7 @@ import { RUN_CODE } from './runtime-bridge-owner.js'
 const CORDIS_PRESET_ID = 'cordis'
 const CORDIS_SKILL_NAME = 'cordis-plugin-development'
 const CORDIS_SKILL_PROVIDER = 'ptc-plus-cordis'
+const COMPANION_SKILL_TOOL = 'skill'
 
 function exactCompanionCandidates(observation) {
   if (Array.isArray(observation)) {
@@ -80,6 +81,40 @@ function requireFiberServices(agent, fiber, owner) {
   }
 }
 
+/**
+ * Companion surfaces the agent scope decides for itself.
+ *
+ * A scope composes its own tools, preset service and Skill service, so one that
+ * omits any of them is not a scope this plugin publishes in yet: the host keeps
+ * authority over the composition, and the missing member can appear later (a
+ * tool registered after this owner loaded, a service provided by a plugin that
+ * loads later). Such an agent therefore stays deferred instead of becoming a
+ * failure, which also keeps this plugin's unavailability out of the host
+ * operation that created it. `undefined` reports a scope without the public
+ * `Context.get` API, whose contradiction the activation guard owns.
+ *
+ * @param {object} agent - the DSH agent scope.
+ * @returns {string[]|undefined} the missing companion surfaces, if any.
+ */
+function absentCompanionSurfaces(agent) {
+  if (typeof agent?.ctx?.get !== 'function') return undefined
+  const missing = []
+  if (agent.ctx.tools?.get?.(RUN_CODE, agent) === undefined) missing.push(`the ${RUN_CODE} tool`)
+  if (agent.ctx.tools?.get?.(COMPANION_SKILL_TOOL, agent) === undefined) {
+    missing.push(`the ${COMPANION_SKILL_TOOL} tool`)
+  }
+  if (agent.ctx.get('agentPresets') === undefined) missing.push('the agentPresets service')
+  if (agent.ctx.get('skills') === undefined) missing.push('the skills service')
+  return missing
+}
+
+/**
+ * Read the services the mount publishes through, and reject a scope whose
+ * exposed service contradicts their public contract. Whether a companion surface
+ * exists at all is decided before the mount ([`absentCompanionSurfaces`]): this
+ * guard owns the shapes, so a service that is present but does not expose the
+ * API the mount calls is a host contradiction rather than a deferred surface.
+ */
 function requireCompanionServices(agent) {
   if (typeof agent?.ctx?.get !== 'function') {
     throw new Error('ptc-plus: cordisToolsEnabled requires the DSH agent Context.get API')
@@ -93,9 +128,6 @@ function requireCompanionServices(agent) {
     || typeof skills.list !== 'function' || typeof skills.get !== 'function') {
     throw new Error('ptc-plus: cordisToolsEnabled requires the DSH skills registerProvider/list/get APIs')
   }
-  if (agent.ctx.tools?.get?.('skill', agent) === undefined) {
-    throw new Error('ptc-plus: cordisToolsEnabled requires the DSH skill tool in the PTC agent scope')
-  }
   return { agentPresets, skills }
 }
 
@@ -234,6 +266,8 @@ export function createCordisToolsOwner(
   }
   const mounts = new Map()
   const pending = new Set()
+  // Agent scopes this owner withdrew from, keyed by the failure it reported.
+  const withdrawn = new Map()
   const cordisInspectLeases = createCordisInspectLeases(ctx)
   const scopedCordisPlugin = cordisInspectLeases.plugin(cordisPlugin)
   const scopedSkillPlugin = exactCompanionSkillPlugin(skillFilesystemPlugin)
@@ -251,19 +285,34 @@ export function createCordisToolsOwner(
   const disposeMount = (agent, mount) => {
     mount.disposed = true
     if (mount.disposal === undefined) {
-      mount.disposal = (async () => {
+      const operation = (async () => {
         const failures = []
-        for (const fiber of [...mount.fibers].reverse()) {
+        const fibers = [...mount.fibers].reverse()
+        const results = await Promise.allSettled(fibers.map(fiber => {
           try {
-            await fiber.dispose()
+            return Promise.resolve(fiber.dispose())
           } catch (error) {
-            failures.push(error)
+            return Promise.reject(error)
+          }
+        }))
+        for (let index = 0; index < results.length; index += 1) {
+          const result = results[index]
+          const fiber = fibers[index]
+          if (result.status === 'rejected') failures.push(result.reason)
+          else {
+            const ownedIndex = mount.fibers.indexOf(fiber)
+            if (ownedIndex !== -1) mount.fibers.splice(ownedIndex, 1)
           }
         }
         if (failures.length > 0) {
           throw new AggregateError(failures, 'ptc-plus Cordis agent mount disposal failed')
         }
       })()
+      mount.disposal = operation
+      operation.then(
+        () => { if (mount.disposal === operation) mount.disposal = undefined },
+        () => { if (mount.disposal === operation) mount.disposal = undefined },
+      )
     }
     return mount.disposal.then(() => {
       if (mounts.get(agent) === mount) mounts.delete(agent)
@@ -272,6 +321,7 @@ export function createCordisToolsOwner(
 
   const disposeAgent = async (agent) => {
     pending.delete(agent)
+    withdrawn.delete(agent)
     const mount = mounts.get(agent)
     if (mount === undefined) return
     await disposeMount(agent, mount)
@@ -280,8 +330,11 @@ export function createCordisToolsOwner(
   const installAgent = (agent) => {
     if (disposed) return Promise.resolve()
     const mounted = mounts.get(agent)
-    if (mounted !== undefined) return mounted.activation
-    if (agent?.ctx?.tools?.get?.(RUN_CODE, agent) === undefined) {
+    if (mounted !== undefined) {
+      return mounted.withdrawn === true ? Promise.resolve() : mounted.activation
+    }
+    const absent = absentCompanionSurfaces(agent)
+    if (absent !== undefined && absent.length > 0) {
       pending.add(agent)
       return Promise.resolve()
     }
@@ -295,6 +348,7 @@ export function createCordisToolsOwner(
       disposal: undefined,
       activated: false,
       disposed: false,
+      withdrawn: false,
     }
     mounts.set(agent, mount)
     mount.activation = Promise.resolve().then(async () => {
@@ -340,10 +394,51 @@ export function createCordisToolsOwner(
     return mount.activation
   }
 
+  /**
+   * Report one agent scope this owner cannot serve and stop retrying it.
+   *
+   * A scope whose exposed preset, services, provider or fiber activation
+   * contradicts the DSH contract is not repaired by a later tool registration,
+   * and DSH sessions create many scopes, so the same failure is reported once
+   * per scope instead of once per turn. The mount is marked so later calls
+   * resolve immediately rather than repeating the attempt and its diagnostic.
+   */
+  const withdraw = (agent, error) => {
+    const mount = mounts.get(agent)
+    if (mount !== undefined) mount.withdrawn = true
+    pending.delete(agent)
+    const message = error instanceof Error ? error.message : String(error)
+    if (withdrawn.get(agent) === message) return
+    withdrawn.set(agent, message)
+    ctx.logger?.warn?.('ptc-plus: Cordis companion tooling withdrew from an agent scope', error)
+  }
+
+  /**
+   * Install for a call the host makes on its own behalf.
+   *
+   * DSH 0.1.6 announces `agent/created` serially and rejects `agents.create()`
+   * when a listener rejects, so a scope this owner cannot serve must withdraw
+   * instead of failing an operation another plugin asked for. Install-time
+   * enumeration stays strict: there the plugin speaks for what it claims to
+   * have published, and `ready` reports the same failure.
+   */
+  const installForHost = (agent) => {
+    let activation
+    try {
+      activation = installAgent(agent)
+    } catch (error) {
+      withdraw(agent, error)
+      return Promise.resolve()
+    }
+    return Promise.resolve(activation).catch(error => {
+      withdraw(agent, error)
+    })
+  }
+
   const promptAssembly = async (_assembly, context, next) => {
     const agent = context?.scope
     if (agent === undefined || mounts.get(agent)?.activated === true) return next()
-    await installAgent(agent)
+    await installForHost(agent)
     if (disposed || mounts.get(agent)?.activated !== true) return next()
     if (typeof ctx.systemPrompt?.assemble !== 'function') {
       throw new Error('ptc-plus: cordisToolsEnabled requires the DSH systemPrompt.assemble API')
@@ -369,7 +464,7 @@ export function createCordisToolsOwner(
   let initialActivations
   try {
     stopPromptAssembly = ctx.on('system-prompt/assemble', promptAssembly, { prepend: true })
-    stopCreated = ctx.on('agent/created', ({ agent }) => installAgent(agent))
+    stopCreated = ctx.on('agent/created', ({ agent }) => installForHost(agent))
     stopDisposed = ctx.on('agent/disposed', ({ agent }) => disposeAgent(agent))
     stopToolsChange = ctx.on('tools/change', retryPending)
     initialActivations = ctx.agents.list().map(installAgent)
@@ -387,26 +482,40 @@ export function createCordisToolsOwner(
   }
 
   let disposal
+  let leasesDisposed = false
   const dispose = () => {
     if (disposal !== undefined) return disposal
     disposed = true
-    stopToolsChange()
-    stopDisposed()
-    stopCreated()
-    stopPromptAssembly()
+    stopToolsChange?.()
+    stopToolsChange = undefined
+    stopDisposed?.()
+    stopDisposed = undefined
+    stopCreated?.()
+    stopCreated = undefined
+    stopPromptAssembly?.()
+    stopPromptAssembly = undefined
     pending.clear()
+    withdrawn.clear()
     const owned = [...mounts.entries()]
     const attempts = owned.map(([agent, mount]) => disposeMount(agent, mount))
-    disposal = Promise.allSettled(attempts).then(results => {
+    const operation = Promise.allSettled(attempts).then(results => {
       const failures = results.filter(result => result.status === 'rejected').map(result => result.reason)
-      try {
-        cordisInspectLeases.dispose()
-      } catch (error) {
-        failures.push(error)
+      if (!leasesDisposed) {
+        try {
+          cordisInspectLeases.dispose()
+          leasesDisposed = true
+        } catch (error) {
+          failures.push(error)
+        }
       }
       if (failures.length > 0) throw new AggregateError(failures, 'ptc-plus Cordis disposal failed')
     })
-    return disposal
+    disposal = operation
+    operation.then(
+      () => { if (disposal === operation) disposal = undefined },
+      () => { if (disposal === operation) disposal = undefined },
+    )
+    return operation
   }
   const ready = Promise.all(initialActivations).then(() => undefined).catch(async error => {
     try {

package/internal/diagnostic.js

@@ -3,9 +3,10 @@ import { assertOwnFields, isRecord } from './record-utils.js'
 
 const DIAGNOSTIC_FIELDS = new Set([
   'code', 'severity', 'phase', 'message', 'stateEffect', 'dispatchState',
-  'source', 'cause', 'help',
+  'source', 'cause', 'help', 'collisions',
 ])
 const SOURCE_FIELDS = new Set(['cell', 'start', 'end'])
+const COLLISION_FIELDS = new Set(['name', 'kind', 'reason', 'start', 'end'])
 const POSITION_FIELDS = new Set(['line', 'column'])
 const CAUSE_FIELDS = new Set(['code', 'message'])
 const SEVERITIES = new Set(['error', 'warning', 'note'])
@@ -26,6 +27,23 @@ function normalizePosition(value, label) {
   return Object.freeze({ line: value.line, column: value.column })
 }
 
+/** One collision record as its compiler owner determined it: the colliding name, its
+ * declaration kind, the reason the producer rejected it, and the original source span. */
+function normalizeCollision(value) {
+  if (!isRecord(value)) throw new Error('invalid dsh-ptc-plus diagnostic collision')
+  assertOwnFields(value, COLLISION_FIELDS, 'diagnostic collision')
+  if (!isLine(value.name) || !isLine(value.kind) || !isLine(value.reason)) {
+    throw new Error('invalid dsh-ptc-plus diagnostic collision')
+  }
+  return Object.freeze({
+    name: value.name,
+    kind: value.kind,
+    reason: value.reason,
+    start: normalizePosition(value.start, 'collision start'),
+    ...(value.end === undefined ? {} : { end: normalizePosition(value.end, 'collision end') }),
+  })
+}
+
 function normalizeCause(value, depth) {
   if (depth > 16) throw new Error('diagnostic cause chain is too deep')
   if (!isRecord(value)) throw new Error('invalid diagnostic cause')
@@ -77,6 +95,13 @@ export function normalizeDiagnostic(value, depth = 0) {
   }
   let cause
   if (value.cause !== undefined) cause = normalizeCause(value.cause, depth)
+  let collisions
+  if (value.collisions !== undefined) {
+    if (!Array.isArray(value.collisions) || value.collisions.length === 0) {
+      throw new Error('invalid dsh-ptc-plus diagnostic collisions')
+    }
+    collisions = Object.freeze(value.collisions.map(collision => normalizeCollision(collision)))
+  }
   let help
   if (value.help !== undefined) {
     if (!Array.isArray(value.help) || value.help.length > 3
@@ -94,6 +119,7 @@ export function normalizeDiagnostic(value, depth = 0) {
     ...(value.dispatchState === undefined ? {} : { dispatchState: value.dispatchState }),
     ...(source === undefined ? {} : { source }),
     ...(cause === undefined ? {} : { cause }),
+    ...(collisions === undefined ? {} : { collisions }),
     ...(help === undefined ? {} : { help }),
   })
 }

package/internal/direct-surface-owner.js

@@ -11,8 +11,10 @@ import {
   generatedRunCodeExecutionArguments,
   generatedRunCodeDescriptionMeta,
 } from './run-code-description.js'
+import { userBindingsConfiguredContext } from './user-bindings.js'
+import { BINDING_AUTHORING_SDK } from './user-binding-authoring.js'
 
-const RUN_CODE_TOOL_DESCRIPTION = 'Evaluate the next TypeScript cell in this session-bound persistent REPL. Earlier top-level bindings remain available, so this call extends the current environment instead of creating a fresh one. Use `code` for the async-function body and `description` for its short UI summary. Successful image-bearing subtool results are attached after the cell.'
+const RUN_CODE_TOOL_DESCRIPTION = 'Evaluate the next TypeScript cell in this session-bound persistent REPL, reusing earlier top-level bindings. Use `code` for the async-function body and `description` for its short UI summary. Successful image-bearing subtool results are attached after the cell.'
 const RUN_CODE_CODE_DESCRIPTION = 'Code for the next REPL cell, parsed as the body of an async TypeScript function.'
 const RUN_CODE_DESCRIPTION_DESCRIPTION = 'Short active-voice summary of what this cell does, 5-10 words (shown in the UI).'
 const CODE_TRANSPORT_INSTRUCTION = '`run_code` and `edit_run_code` are the only tools callable directly. Call every native tool declared by the SDK from inside a program.'
@@ -42,11 +44,13 @@ function adaptRunCodeSchema(tool) {
   }
 }
 
-function capabilitySdk(nativeSdk) {
+function capabilitySdk(nativeSdk, userBindingsEnabled) {
   return `${projectProgramSdk(nativeSdk)}
 
 ## PTC Plus program capabilities
 
+Discover program APIs without calling them. \`tree()\` lists namespaces and members; \`inspect()\` describes selected \`namespace.member\` symbols. \`find()\` matches case-insensitive symbols or contiguous words, separating CamelCase and punctuation. Use short queries such as \`"read"\`; if none match, shorten the query or check \`tree()\`. Missing metadata is unknown.
+
 \`\`\`ts
 declare class CapabilityExplorationError extends Error { readonly operation: "tree" | "find" | "inspect" }
 declare const capabilities: {
@@ -54,7 +58,7 @@ declare const capabilities: {
   find(query: string): Promise<Array<{ symbol: string; description?: string; completeness: string; effect: string; replay: string }>>
   inspect(args?: { symbols?: string[]; budget?: number }): Promise<{ symbols: unknown[]; omitted: number; unknown: string[]; budget: number }>
 }
-\`\`\``
+\`\`\`${userBindingsEnabled ? `\n${BINDING_AUTHORING_SDK}` : ''}`
 }
 
 function rejection(message) {
@@ -141,6 +145,8 @@ export function createDirectSurfaceOwner({
   canonicalizeToolCalls,
   sessionId,
   toolSchemasForAgent,
+  userBindingsForAgent = async () => undefined,
+  setAgentPresentation = async () => {},
 }) {
   // Composition is anchored to Agent identity because DSH selects presentation
   // once per composed agent. Request signals bind the exact assembly to stream
@@ -151,6 +157,7 @@ export function createDirectSurfaceOwner({
   const canonicalRequests = new WeakMap()
   const sessions = new Map()
   const cordisRecovery = createCordisRecoveryPolicy(runtimeConfig.cordisToolsEnabled)
+  let disposed = false
   let currentCanonicalizeToolCalls = canonicalizeToolCalls
   let currentAutoDescribeRunCode = runtimeConfig.autoDescribeRunCode
   const tipConfig = {
@@ -193,9 +200,31 @@ export function createDirectSurfaceOwner({
     return undefined
   }
 
-  const rememberRequest = (id, signal, presentation, nativeSchemas, autoDescribeRunCode) => {
+  // One dispatch resolves the policy captured for its exact call, then the
+  // request bound to its signal, then the session's latest request.
+  const dispatchPolicy = (exec) => {
+    const id = sessionId(exec.agent)
+    return executionPolicy(id, exec.callId) ?? requestPolicy(exec?.signal, id)
+  }
+
+  const rememberRequest = (
+    id,
+    signal,
+    presentation,
+    nativeSchemas,
+    autoDescribeRunCode,
+    userBindings,
+    contexts = [],
+  ) => {
     const owner = sessionOwner(id)
-    const request = { presentation, nativeSchemas, autoDescribeRunCode, owner }
+    const request = {
+      presentation,
+      nativeSchemas,
+      autoDescribeRunCode,
+      owner,
+      contexts,
+      ...(userBindings === undefined ? {} : { userBindings }),
+    }
     owner.latestRequest = request
     if (signal !== undefined) canonicalRequests.set(signal, request)
   }
@@ -228,6 +257,9 @@ export function createDirectSurfaceOwner({
       const autoDescribeRunCode = currentAutoDescribeRunCode
       const agent = context?.agent
       const id = sessionId(agent)
+      const requestOwner = id === undefined ? undefined : sessionOwner(id)
+      const isCurrent = () => !disposed && (requestOwner === undefined
+        || (requestOwner.active && sessions.get(id) === requestOwner))
       const initialState = presentationState(initialAssembly)
       let composition = compositions.get(agent)
       if (composition === undefined && id !== undefined
@@ -239,6 +271,7 @@ export function createDirectSurfaceOwner({
       }
 
       const assembly = await next()
+      if (!isCurrent()) return assembly
       const tools = assembly.tools
       if (!Array.isArray(tools)) {
         throw new Error('ptc-plus: incompatible prompt assembly; expected a tools array')
@@ -260,16 +293,22 @@ export function createDirectSurfaceOwner({
         if (presentation !== 'native') {
           throw new Error(`ptc-plus: ${presentation} agent composition assembled without run_code`)
         }
+        await setAgentPresentation(agent, presentation)
+        if (!isCurrent()) return assembly
         if (id !== undefined) {
-          rememberRequest(id, requestSignal, 'native', new Map(), autoDescribeRunCode)
+          rememberRequest(id, requestSignal, 'native', new Map(), autoDescribeRunCode, undefined)
         }
         return assembly
       }
       if (presentation === 'native') {
         throw new Error('ptc-plus: native agent composition assembled with run_code')
       }
+      await setAgentPresentation(agent, presentation)
+      if (!isCurrent()) return assembly
       const sessionPtc = presentation !== 'native' && id !== undefined
       const sessionPtcProjection = presentation === 'ptc' && id !== undefined
+      const userBindings = sessionPtc ? await userBindingsForAgent(agent) : undefined
+      if (!isCurrent()) return assembly
       const runCode = tools.find(tool => tool?.name === RUN_CODE)
       let directTools = tools
       if (sessionPtcProjection) {
@@ -283,17 +322,18 @@ export function createDirectSurfaceOwner({
           },
         })
         : { contexts: [] }
-      const contexts = sessionPtc && Array.isArray(assembly.contexts)
-        && runtimeContexts.contexts.length > 0
-        ? [...assembly.contexts, ...runtimeContexts.contexts]
-        : assembly.contexts
+      const bindingDefaults = userBindings === undefined ? undefined : userBindingsConfiguredContext(userBindings)
+      const contexts = [
+        ...runtimeContexts.contexts,
+        ...(bindingDefaults === undefined ? [] : [bindingDefaults]),
+      ]
       const projectsSections = presentation !== 'native' && Array.isArray(assembly.sections)
         && assembly.sections.some(section => section?.name === 'tools:sdk'
           || (sessionPtcProjection && section?.name === completedState.collapseSectionName))
       const sections = projectsSections
         ? assembly.sections.map(section => {
             if (section?.name === 'tools:sdk') {
-              return { ...section, text: capabilitySdk(section.text) }
+              return { ...section, text: capabilitySdk(section.text, userBindings !== undefined) }
             }
             if (sessionPtcProjection && section?.name === completedState.collapseSectionName) {
               return { ...section, text: CODE_TRANSPORT_INSTRUCTION }
@@ -301,7 +341,6 @@ export function createDirectSurfaceOwner({
             return section
           })
         : assembly.sections
-
       if (id !== undefined) {
         const nativeSchemas = presentation === 'ptc'
           ? new Map(toolSchemasForAgent(agent)
@@ -309,7 +348,15 @@ export function createDirectSurfaceOwner({
               && schema.name !== RUN_CODE && schema.name !== EDIT_RUN_CODE)
             .map(schema => [schema.name, schema]))
           : new Map()
-        rememberRequest(id, requestSignal, presentation, nativeSchemas, autoDescribeRunCode)
+        rememberRequest(
+          id,
+          requestSignal,
+          presentation,
+          nativeSchemas,
+          autoDescribeRunCode,
+          userBindings,
+          contexts,
+        )
       }
 
       return {
@@ -320,9 +367,11 @@ export function createDirectSurfaceOwner({
             ? adaptRunCodeSchema(tool)
             : tool),
         sections,
-        contexts,
       }
     },
+    contextsForRequest(context) {
+      return requestPolicy(context.signal, sessionId(context.agent))?.contexts ?? []
+    },
     stream(options, next) {
       const optionSessionId = options.sessionId === undefined ? undefined : String(options.sessionId)
       const policy = requestPolicy(options?.signal, optionSessionId)
@@ -340,9 +389,7 @@ export function createDirectSurfaceOwner({
       if (exec.name === EDIT_RUN_CODE && exec.parent !== undefined) {
         return rejection(`tool ${EDIT_RUN_CODE} is only callable directly in PTC mode; call native tools from inside run_code`)
       }
-      const id = sessionId(exec.agent)
-      const policy = executionPolicy(id, exec.callId)
-        ?? requestPolicy(exec?.signal, id)
+      const policy = dispatchPolicy(exec)
       if (exec.name === EDIT_RUN_CODE) {
         return policy?.presentation === 'ptc'
           ? undefined
@@ -355,9 +402,7 @@ export function createDirectSurfaceOwner({
       return rejection(`tool ${exec.name} is not a direct PTC tool; use run_code or edit_run_code directly, and call native tools from inside run_code`)
     },
     executionArguments(exec) {
-      const id = sessionId(exec.agent)
-      const policy = executionPolicy(id, exec.callId)
-        ?? requestPolicy(exec?.signal, id)
+      const policy = dispatchPolicy(exec)
       const originalArguments = exec.arguments
       if (exec.name !== RUN_CODE || exec.parent !== undefined
         || policy?.autoDescribeRunCode !== true || policy.presentation === 'native'
@@ -367,6 +412,10 @@ export function createDirectSurfaceOwner({
       }
       return generatedRunCodeExecutionArguments(originalArguments)
     },
+    executionUserBindings(exec) {
+      const policy = dispatchPolicy(exec)
+      return policy?.presentation === 'native' ? undefined : policy?.userBindings
+    },
     argumentDiagnostic(exec, result) {
       // DSH uses success-result identity to avoid re-running output projectors
       // after this middleware's settlement scope has ended.
@@ -377,9 +426,7 @@ export function createDirectSurfaceOwner({
         : { ...result, ...(meta === undefined ? {} : { meta }) }
       const missingPath = missingDescriptionPath(diagnosed.error)
       if (missingPath === undefined) return diagnosed
-      const id = sessionId(exec.agent)
-      const policy = executionPolicy(id, exec.callId)
-        ?? requestPolicy(exec?.signal, id)
+      const policy = dispatchPolicy(exec)
       const outer = missingPath === 'description'
         && policy?.autoDescribeRunCode !== true
         && !(isRecord(exec.arguments) && typeof exec.arguments.description === 'string')
@@ -410,7 +457,13 @@ export function createDirectSurfaceOwner({
       clearCompositionsForSession(id)
       clearSession(id)
     },
+    resetSessionComposition(session) {
+      const id = String(session.id ?? session)
+      clearCompositionsForSession(id)
+      clearSession(id)
+    },
     dispose() {
+      disposed = true
       compositions.clear()
       for (const owner of sessions.values()) owner.active = false
       sessions.clear()

package/internal/dynamic-binding-evidence.js

@@ -0,0 +1,16 @@
+import { parseExpression } from '@babel/parser'
+
+/** Dynamic names require both a native identifier and their exact source origin. */
+export function dynamicBindingOrigin(target, name, origins) {
+  if (typeof target !== 'string' || typeof name !== 'string') return undefined
+  const suffix = `:${JSON.stringify(name)}`
+  if (!target.endsWith(suffix)) return undefined
+  const origin = target.slice(0, -suffix.length)
+  if (!origins.has(origin)) return undefined
+  try {
+    const identifier = parseExpression(name)
+    return identifier.type === 'Identifier' && identifier.name === name ? origin : undefined
+  } catch {
+    return undefined
+  }
+}