dsh-ptc-plus 0.4.1 → 0.4.3

package/internal/binding-update-policy.js

@@ -1,6 +1,7 @@
 import { LIVE_MODULE_SEMANTICS } from './repl-rewrite-contract.js'
 import { LEGACY_LANGUAGE_SEMANTICS, STATEFUL_LANGUAGE_SEMANTICS,
   PROTECTED_LANGUAGE_SEMANTICS, normalizeLanguageSemantics } from './language-semantics.js'
+import { moduleTransformForLanguage, normalizeModuleTransform } from './module-transform-contract.js'
 
 /**
  * Translate the public compatibility settings into the execution policy used
@@ -15,8 +16,10 @@ export function executionPolicies(config, replayRecord = undefined) {
     const bindingPolicy = Object.freeze({ ...replayRecord.bindingPolicy })
     const rewritesEnabled = Object.freeze({ ...replayRecord.rewritePolicy })
     const moduleSemantics = Object.freeze({ ...replayRecord.moduleSemantics })
+    const languageSemantics = normalizeLanguageSemantics(replayRecord.languageSemantics ?? LEGACY_LANGUAGE_SEMANTICS)
     return Object.freeze({
-      languageSemantics: normalizeLanguageSemantics(replayRecord.languageSemantics ?? LEGACY_LANGUAGE_SEMANTICS),
+      languageSemantics,
+      moduleTransform: normalizeModuleTransform(replayRecord.moduleTransform, languageSemantics),
       bindingPolicy,
       rewritesEnabled,
       moduleSemantics,
@@ -25,6 +28,7 @@ export function executionPolicies(config, replayRecord = undefined) {
   if (config.bindingUpdates === 'stateful' && config.legacyBindingSettings !== true) {
     return Object.freeze({
       languageSemantics: STATEFUL_LANGUAGE_SEMANTICS,
+      moduleTransform: moduleTransformForLanguage(STATEFUL_LANGUAGE_SEMANTICS),
       bindingPolicy: Object.freeze({ variableRedeclarations: true, functionClassRedeclarations: true }),
       rewritesEnabled: Object.freeze({ autoRewriteImports: true, autoStripExports: true, autoSplitRedeclarations: true }),
       moduleSemantics: LIVE_MODULE_SEMANTICS,
@@ -33,6 +37,7 @@ export function executionPolicies(config, replayRecord = undefined) {
   if (config.bindingUpdates === 'protected' && config.legacyBindingSettings !== true) {
     return Object.freeze({
       languageSemantics: PROTECTED_LANGUAGE_SEMANTICS,
+      moduleTransform: moduleTransformForLanguage(PROTECTED_LANGUAGE_SEMANTICS),
       bindingPolicy: Object.freeze({ variableRedeclarations: false, functionClassRedeclarations: false }),
       // Module syntax is part of the language in protected mode too.  The
       // policy protects existing names; it does not remove valid syntax.
@@ -42,6 +47,7 @@ export function executionPolicies(config, replayRecord = undefined) {
   }
   return Object.freeze({
     languageSemantics: LEGACY_LANGUAGE_SEMANTICS,
+    moduleTransform: moduleTransformForLanguage(LEGACY_LANGUAGE_SEMANTICS),
     bindingPolicy: Object.freeze({
       variableRedeclarations: config.looseTopLevelRedeclarations === true,
       functionClassRedeclarations: config.looseTopLevelFunctionClassRedeclarations === true,

package/internal/callable-source-facts.js

@@ -43,6 +43,16 @@ function callableSourceStart(source, node) {
   return start + tokens.getToken().start
 }
 
+function removeCallableSourceMarks(source, prefix, suffix, sources, options) {
+  const tree = parse(prefix + source + suffix, options)
+  const markers = new Set(sources.entries.map(entry => entry.marker))
+  const offset = prefix.length
+  const edits = tree.comments.filter(comment => markers.has(comment.value)
+    && comment.start >= offset && comment.end <= offset + source.length)
+    .map(comment => ({ start: comment.start - offset, end: comment.end - offset, text: '' }))
+  return edits.length === 0 ? source : applySourceEdits(source, identitySourceMap(source.length), edits).code
+}
+
 export function callableMarkerPosition(node, source, comments) {
   if (node.type !== 'ArrowFunctionExpression') return node.body.start + 1
   let start = source.lastIndexOf('=>', node.body.start - 1)
@@ -129,6 +139,7 @@ export function markCallableSources(source, sourceMap = identitySourceMap(source
   const nativeFunctions = typedRecords.map(record => markedNodes.get(record.marker))
     .filter(node => t.isFunction(node) && !isMethod(node)).sort((left, right) => left.start - right.start)
   const nativeRecipes = new Map()
+  const aliasMarkers = []
   const nativeFunctionIndex = start => {
     let low = 0, high = nativeFunctions.length
     while (low < high) {
@@ -175,7 +186,17 @@ export function markCallableSources(source, sourceMap = identitySourceMap(source
       original = lowered.source
       const entries = [...originals].map(([key, text]) => [key, key === marker ? original : text])
       for (const [node, fact] of markedCallableOwners(lowered.emitted, entries)) {
-        sources.aliases.push([lowered.emittedSource.slice(node.start, node.end), fact.original])
+        const generated = lowered.emittedSource.slice(node.start, node.end)
+        aliasMarkers.push([generated, fact.marker])
+        const generatedMethod = isMethod(node)
+        const markerFree = removeCallableSourceMarks(
+          generated,
+          generatedMethod ? 'class Source {' : '(',
+          generatedMethod ? '}' : ')',
+          sources,
+          options,
+        )
+        if (markerFree !== generated) aliasMarkers.push([markerFree, fact.marker])
       }
     }
     // Prefer source-preserving erasure. Runtime TypeScript constructs such as
@@ -202,6 +223,7 @@ export function markCallableSources(source, sourceMap = identitySourceMap(source
     } catch {
       lowerCallable()
     }
+    original = removeCallableSourceMarks(original, prefix, suffix, sources, options)
     entry.buffer = sources.buffers.length
     sources.buffers.push(original)
     entry.start = 0
@@ -209,6 +231,8 @@ export function markCallableSources(source, sourceMap = identitySourceMap(source
     originals.set(marker, original)
     if (!method && t.isFunction(node)) nativeRecipes.set(node, { node, start, end: node.end, text: original })
   }
+  const finalFacts = factMap(sources)
+  for (const [generated, marker] of aliasMarkers) sources.aliases.push([generated, originalText(finalFacts.get(marker))])
   return { ...marked, callableSources: sources, nativeJavaScript }
 }
 
@@ -273,6 +297,18 @@ export function collectCallableSources(code, sources, parserOptions = {}, transf
   }).concat(sources.aliases ?? [])
 }
 
+/** Restore only callable marks whose transformed starts have exact source-map ownership. */
+export function restoreMappedCallableSourceMarks(mapped, input, transformation, sources, parserOptions = {}) {
+  if (sources === undefined || sources.length === 0) return mapped
+  const { tree, owners } = callableSourceOwners(mapped.code, sources, parserOptions,
+    { code: input, map: transformation.map })
+  const edits = [...owners].map(([node, fact]) => {
+    const start = callableMarkerPosition(node, mapped.code, tree.comments)
+    return { start, end: start, text: `/*${fact.marker}*/` }
+  })
+  return edits.length === 0 ? mapped : applySourceEdits(mapped.code, mapped.sourceMap, edits)
+}
+
 /** Emission ranges come from typed nodes and exact generator mappings. */
 export function regionCallableRanges(input, generated, sourceRanges, parserOptions) {
   if (!sourceRanges?.length) return []

package/internal/cell-analysis.js

@@ -17,10 +17,10 @@ import {
   renderDurabilityReason,
   renderDurabilityReasons,
 } from './module-policy.js'
-import { applySourceEdits, mapSourcePosition, mapSourceSpan } from './source-position-map.js'
+import { applySourceEdits, mapSourcePosition, mapSourceSpan, sourceRangeHasOriginalText } from './source-position-map.js'
 import { SKIP_AST_CHILDREN, walkAst } from './ast-traversal.js'
 import { compileStatefulRoot } from './stateful-root-compiler.js'
-import { CELL_PARSER_PLUGINS, bindCompilerIntrinsics, lowerStatefulDecorators, lowerStatefulResources, lowerNativeLanguageSource, normalizeStatefulScopes } from './repl-scope-normalizer.js'
+import { CELL_PARSER_PLUGINS, bindCompilerIntrinsics, lowerStatefulDecorators, lowerStatefulResources, lowerNativeLanguageSource, normalizationFailureInput, normalizeStatefulScopes } from './repl-scope-normalizer.js'
 import { markCallableSources, collectCallableSources } from './callable-source-facts.js'
 import { LegacyPreflightError, prepareLegacyProgram } from './legacy-cell-analysis.js'
 import { adaptLegacyModuleImports } from './managed-module-operations.js'
@@ -220,6 +220,49 @@ function isFunction(node) {
     || node.type === 'ArrowFunctionExpression'
 }
 
+function lowerCellImportMeta(result, importMeta, originalSource) {
+  if (!result.code.includes('import')) return result
+  const tree = parseSource(result.code, {
+    sourceType: 'unambiguous',
+    errorRecovery: true,
+    allowAwaitOutsideFunction: true,
+    allowImportExportEverywhere: true,
+    allowReturnOutsideFunction: true,
+    allowUndeclaredExports: true,
+    plugins: CELL_PARSER_PLUGINS,
+  }).program
+  const references = []
+  walkAst(tree, (node) => {
+    if (node.type === 'MetaProperty' && node.meta?.name === 'import' && node.property?.name === 'meta') {
+      references.push(node)
+    }
+  })
+  if (references.length === 0) return result
+  if (importMeta === null || typeof importMeta !== 'object'
+    || typeof importMeta.url !== 'string' || typeof importMeta.filename !== 'string'
+    || typeof importMeta.dirname !== 'string') {
+    const node = references[0]
+    throw new ModuleRewriteError('import.meta requires the session module base', mapSourcePosition({
+      line: node.loc.start.line,
+      column: node.loc.start.column + 1,
+    }, result.code, originalSource, result.sourceMap))
+  }
+  const binding = createGeneratedNameAllocator(tree)('import_meta')
+  const directiveEnd = tree.directives.at(-1)?.end ?? tree.interpreter?.end ?? 0
+  const declaration = `\nconst ${binding}={__proto__:null,url:${JSON.stringify(importMeta.url)},filename:${JSON.stringify(importMeta.filename)},dirname:${JSON.stringify(importMeta.dirname)}};\n`
+  const edits = [
+    { start: directiveEnd, end: directiveEnd, text: declaration },
+    ...references.map(node => ({
+      start: node.start,
+      end: node.end,
+      text: binding,
+      mappings: [{ generatedStart: 0, generatedEnd: binding.length,
+        originalStart: node.start, originalEnd: node.end }],
+    })),
+  ]
+  return { ...result, ...applySourceEdits(result.code, result.sourceMap, edits), importMetaBinding: binding }
+}
+
 
 function staticModuleClassification(moduleLoads) {
   const reasons = new Map()
@@ -240,7 +283,9 @@ function staticModuleClassification(moduleLoads) {
 }
 
 /** Conservatively classify a cell before giving it non-journalable capability. */
-export function classifyDurability(code, knownBindings = new Set(), { sourceType = 'script', internalModules = new Set() } = {}) {
+export function classifyDurability(code, knownBindings = new Set(), {
+  sourceType = 'script', internalModules = new Set(), sourceMap = undefined, originalSource = undefined,
+} = {}) {
   let body
   let moduleLoads = []
   if (sourceType === 'module') {
@@ -280,14 +325,16 @@ export function classifyDurability(code, knownBindings = new Set(), { sourceType
   const reasons = new Map()
   const addReason = reason => reasons.set(renderDurabilityReason(reason), reason)
   for (const reason of staticModuleClassification(moduleLoads)) addReason(reason)
-  const classifyModule = (source) => {
+  const classifyModule = (source, form) => {
     if (source?.type !== 'Literal' || typeof source.value !== 'string') {
       addReason(DYNAMIC_MODULE_REASON)
       return
     }
     const classification = classifyModuleSource(source.value)
     if (classification.status === 'forbidden') {
-      throw new PreflightError(`cell import of ${source.value} is forbidden because it exposes kernel control`, source)
+      const span = sourceMap === undefined || originalSource === undefined ? declarationSpan(source)
+        : mapSourceSpan(declarationSpan(source), code, originalSource, sourceMap)
+      throw new PreflightError(`cell ${form} of ${source.value} is forbidden because it exposes kernel control`, undefined, span)
     }
     if (classification.reason !== undefined) addReason(classification.reason)
   }
@@ -297,11 +344,12 @@ export function classifyDurability(code, knownBindings = new Set(), { sourceType
     }
     return false
   }
-  walkAst(body, (node, parent, parentKey, { scopes, strict }) => {
+  walkAst(body, (node, parent, parentKey, { scopes, strict, thisIsGlobal }) => {
     let nestedScopes = scopes
     if (isFunction(node)) {
       strict ||= hasStrictDirective(node.body)
       nestedScopes = [...scopes, functionParameterBindings(node)]
+      if (node.type !== 'ArrowFunctionExpression') thisIsGlobal = false
     } else if (node.type === 'BlockStatement' && node !== body) {
       const names = directBlockBindings(node.body)
       if (isFunction(parent)) addFunctionVariables(node, names, strict)
@@ -324,11 +372,16 @@ export function classifyDurability(code, knownBindings = new Set(), { sourceType
       nestedScopes = [...scopes, loopBindings(node)]
     }
     if (node.type === 'ImportExpression') {
-      classifyModule(node.source)
+      classifyModule(node.source, 'import')
+    }
+    const sourceOwnedThis = sourceMap === undefined
+      || sourceRangeHasOriginalText(sourceMap, code, originalSource, node.start, node.end)
+    if (node.type === 'ThisExpression' && thisIsGlobal && sourceOwnedThis) {
+      addReason(Object.freeze({ kind: 'ambient', name: 'globalThis' }))
     }
     if (node.type === 'CallExpression' && node.callee?.type === 'Identifier' && node.callee.name === 'require'
       && !isBound('require', nestedScopes)) {
-      classifyModule(node.arguments[0])
+      classifyModule(node.arguments[0], 'require')
     }
     if (node.type === 'Identifier' && isReferenceIdentifier(node, parent, parentKey)
       && !isBound(node.name, nestedScopes) && AMBIENT_GLOBALS.has(node.name)
@@ -367,8 +420,8 @@ export function classifyDurability(code, knownBindings = new Set(), { sourceType
         addReason(Object.freeze({ kind: 'ambient', name: 'Math' }))
       }
     }
-    return { scopes: nestedScopes, strict }
-  }, undefined, { scopes: [rootBindings], strict: rootStrict })
+    return { scopes: nestedScopes, strict, thisIsGlobal }
+  }, undefined, { scopes: [rootBindings], strict: rootStrict, thisIsGlobal: sourceType === 'script' })
   return {
     durability: reasons.size === 0 ? 'durable' : 'volatile',
     reasons: Object.freeze([...reasons.values()]),
@@ -454,31 +507,46 @@ export function prepareProgram(program, options = {}) {
     let normalized
     let prepared
     let callableSources
+    let diagnosticInput
     const intrinsicContext = { bindings: new Set() }
     try {
       const marked = markCallableSources(program, undefined, { plugins: CELL_PARSER_PLUGINS, allowImportExportEverywhere: true, allowUndeclaredExports: true },
         { lowerNativeSource: lowerNativeLanguageSource, nativeUsing: options.nativeUsing })
+      const moduleMetadata = lowerCellImportMeta(marked, options.importMeta, program)
+      diagnosticInput = moduleMetadata
       callableSources = marked.callableSources
-      normalized = normalizeStatefulScopes(marked.code, marked.sourceMap, { mode: options.languageSemantics,
-        nativeJavaScript: marked.nativeJavaScript, deferDecorators: true, deferResources: true, intrinsicContext })
+      normalized = normalizeStatefulScopes(moduleMetadata.code, moduleMetadata.sourceMap, { mode: options.languageSemantics,
+        callableSources, nativeJavaScript: marked.nativeJavaScript,
+        deferDecorators: true, deferResources: true, intrinsicContext })
+      if (moduleMetadata.importMetaBinding !== undefined) {
+        normalized.internalBindings = new Set(normalized.internalBindings)
+        normalized.internalBindings.add(moduleMetadata.importMetaBinding)
+      }
+      diagnosticInput = normalized
       prepared = compileStatefulRoot(normalized.code, { ...options, sourceMap: normalized.sourceMap,
         internalBindings: normalized.internalBindings, dynamicBindings: normalized.dynamicBindings,
         privateBindings: normalized.privateBindings, originalSource: program })
     } catch (error) {
       if (error instanceof ModuleRewriteError) throw error
       const position = error.loc === undefined ? undefined : { line: error.loc.line, column: error.loc.column + 1 }
-      throw new ModuleRewriteError(error.message, normalized === undefined ? position
-        : mapSourcePosition(position, normalized.code, program, normalized.sourceMap))
+      const failureInput = normalizationFailureInput(error) ?? diagnosticInput
+      throw new ModuleRewriteError(error.message, failureInput === undefined ? position
+        : mapSourcePosition(position, failureInput.code, program, failureInput.sourceMap))
     }
     prepared = { ...prepared, deferredHelpers: normalized.deferredHelpers }
     intrinsicContext.expression = `this[${JSON.stringify(prepared.rootRuntimeName)}].intrinsics`
     const classificationSource = bindCompilerIntrinsics(lowerStatefulDecorators(
-      { ...prepared, code: prepared.classificationCode }, undefined, intrinsicContext), intrinsicContext).code
+      { ...prepared, code: prepared.classificationCode, sourceMap: prepared.classificationSourceMap },
+      undefined, intrinsicContext), intrinsicContext)
     prepared = bindCompilerIntrinsics(lowerStatefulDecorators(prepared, undefined, intrinsicContext), intrinsicContext)
     prepared = lowerStatefulResources(prepared, { intrinsicContext, nativeUsing: options.nativeUsing })
     const parsed = parseExecutableCell(prepared.code, { eraseTypes: true })
-    const classification = classifyDurability(parseExecutableCell(classificationSource, { eraseTypes: true }).code,
-      new Set([...(options.knownBindings ?? []), ...prepared.declared]))
+    const classificationCode = parseExecutableCell(classificationSource.code, { eraseTypes: true }).code
+    const classification = classifyDurability(classificationCode,
+      new Set([...(options.knownBindings ?? []), ...prepared.declared]), {
+        sourceMap: classificationSource.sourceMap,
+        originalSource: program,
+      })
     const reasons = [...staticModuleClassification(prepared.moduleLoads), ...classification.reasons]
     const lowered = rewriteCellReturns(parsed.code, prepared.sourceMap,
       new Set([...prepared.declared, ...(options.knownBindings ?? [])]))

package/internal/compiler-intrinsics.js

@@ -1,15 +1,12 @@
 import { stringifyCompilerData } from './compiler-data.js'
 import { compilerStorageSource } from './compiler-storage-source.js'
 import { compilerDescriptorSource } from './compiler-descriptors.js'
+import { runtimeIntrinsics } from './runtime-intrinsics.js'
 
 /** Compiler operations are captured before an owned realm executes user code. */
 const defaultRealmFunction = Function
 const realms = new WeakMap()
-const uncurry = Function.prototype.bind.bind(Function.prototype.call)
-const weakMapGet = uncurry(WeakMap.prototype.get)
-const weakMapSet = uncurry(WeakMap.prototype.set)
-const mapKeys = uncurry(Map.prototype.keys)
-const mapIteratorNext = uncurry(Object.getPrototypeOf(new Map().keys()).next)
+const { weakMapGet, weakMapSet } = runtimeIntrinsics
 
 export function captureCompilerIntrinsics(realmFunction = defaultRealmFunction) {
   let intrinsics = weakMapGet(realms, realmFunction)
@@ -21,7 +18,8 @@ export function captureCompilerIntrinsics(realmFunction = defaultRealmFunction)
     const object=properties.Object;
     const symbol=Symbol;
     return {Object:object,WeakMap,WeakSet,unscopables:symbol.unscopables,Reflect:{apply:nativeReflect.apply,
-      construct:nativeReflect.construct,ownKeys:nativeReflect.ownKeys,defineProperty:properties.reflectDefineProperty,
+      construct:nativeReflect.construct,deleteProperty:nativeReflect.deleteProperty,has:nativeReflect.has,
+      ownKeys:nativeReflect.ownKeys,defineProperty:properties.reflectDefineProperty,
       get decorate(){return nativeReflect.decorate}},TypeError,ReferenceError,SyntaxError,Error,Symbol,String,Number,
       Promise:{resolve:Promise.resolve.bind(Promise),reject:Promise.reject.bind(Promise)},
       SuppressedError:typeof SuppressedError==='function'?SuppressedError:undefined,
@@ -36,49 +34,17 @@ export const moduleCompilerIntrinsics = captureCompilerIntrinsics()
 /** Internal graph records use captured collection operations. Source-owned
  * objects and callbacks keep their original realm and observable methods. */
 export const moduleRuntimeIntrinsics = {
+  ...runtimeIntrinsics,
   Object: moduleCompilerIntrinsics.Object,
   Reflect: moduleCompilerIntrinsics.Reflect,
   Error: moduleCompilerIntrinsics.Error,
-  Map, Set, WeakMap, Proxy,
-  mapGet: uncurry(Map.prototype.get),
-  mapHas: uncurry(Map.prototype.has),
-  mapSet: uncurry(Map.prototype.set),
-  mapDelete: uncurry(Map.prototype.delete),
-  mapClear: uncurry(Map.prototype.clear),
-  mapSize: uncurry(Object.getOwnPropertyDescriptor(Map.prototype, 'size').get),
-  mapFirstKey: value => mapIteratorNext(mapKeys(value)).value,
-  mapForEach: uncurry(Map.prototype.forEach),
-  setHas: uncurry(Set.prototype.has),
-  setAdd: uncurry(Set.prototype.add),
-  setDelete: uncurry(Set.prototype.delete),
-  setClear: uncurry(Set.prototype.clear),
-  setForEach: uncurry(Set.prototype.forEach),
-  weakMapHas: uncurry(WeakMap.prototype.has),
-  weakMapGet, weakMapSet,
-  isArray: Array.isArray,
-  includes: uncurry(Array.prototype.includes),
-  join: uncurry(Array.prototype.join),
-  sliceString: uncurry(String.prototype.slice),
-  replaceAllString: uncurry(String.prototype.replaceAll),
-  includesString: uncurry(String.prototype.includes),
-  floor: Math.floor,
-  min: Math.min,
-  max: Math.max,
+  TypeError: moduleCompilerIntrinsics.TypeError,
   // Only private native Promises enter this boundary. Source promises and the
   // public result keep their prototypes; private reactions cannot select a
   // source constructor/species or dynamically dispatch through then/catch.
   observeOwnedPromise: moduleCompilerIntrinsics.observeOwnedPromise,
-  appendArray(target, value) {
-    moduleCompilerIntrinsics.Object.defineProperty(target, target.length,
-      { value, writable: true, enumerable: true, configurable: true })
-    return target
-  },
-  copyArray(source, start = 0, end = source.length, target = []) {
-    for (let index = start; index < end; index++) this.appendArray(target, source[index])
-    return target
-  },
-  sort: uncurry(Array.prototype.sort),
-  compare: uncurry(String.prototype.localeCompare),
-  startsWith: uncurry(String.prototype.startsWith),
+  promiseThen: moduleCompilerIntrinsics.promiseThen,
+  promiseResolve: moduleCompilerIntrinsics.Promise.resolve,
+  promiseReject: moduleCompilerIntrinsics.Promise.reject,
   stringify: stringifyCompilerData,
 }

package/internal/compiler-module-links.js

@@ -1,6 +1,9 @@
 import { fileURLToPath } from 'node:url'
 
 const encodeReference = encodeURIComponent
+const objectEntries = Object.entries
+const sortArray = Function.prototype.call.bind(Array.prototype.sort)
+const jsonStringify = JSON.stringify
 
 // These ambient inputs must remain outside source-owned CommonJS bindings.
 export const commonJsCompilerGlobals = new Set(['process'])
@@ -21,14 +24,14 @@ const ATTRIBUTED_LINK_KIND = 'static-attributed'
  * attribute-free links keep the reference they had before attributes were
  * distinguished. */
 export function staticModuleLinkReference(source, attributes) {
-  const entries = Object.entries(attributes ?? {})
+  const entries = objectEntries(attributes ?? {})
   if (entries.length === 0) return compilerModuleReference(STATIC_LINK_KIND, source)
-  entries.sort((left, right) => left[0] < right[0] ? -1 : left[0] > right[0] ? 1 : 0)
-  return compilerModuleReference(ATTRIBUTED_LINK_KIND, JSON.stringify([source, entries]))
+  sortArray(entries, (left, right) => left[0] < right[0] ? -1 : left[0] > right[0] ? 1 : 0)
+  return compilerModuleReference(ATTRIBUTED_LINK_KIND, jsonStringify([source, entries]))
 }
 
 /** Compiler helpers resolve from their own URL, independently of source-owned
  * wrapper bindings and the ESM translator's restricted CommonJS require. */
 export function commonJsCompilerImport(url) {
-  return `process.getBuiltinModule('module').createRequire(${JSON.stringify(url.href)})(${JSON.stringify(fileURLToPath(url))})`
+  return `process.getBuiltinModule('module').createRequire(${jsonStringify(url.href)})(${jsonStringify(fileURLToPath(url))})`
 }

package/internal/config-spec.js

@@ -96,7 +96,7 @@ export const CONFIG_FIELDS = Object.freeze([
   {
     key: 'userBindingsEnabled',
     type: 'boolean',
-    default: false,
+    default: true,
     label: '启用全局用户 Binding',
     labelEn: 'Enable Global User Bindings',
     description: '管理 TypeScript helper，并将已启用条目作为跨会话的默认 REPL 绑定。',

package/internal/cordis-tools-owner.js

@@ -133,12 +133,22 @@ function requireCompanionServices(agent) {
 
 async function companionSkillDirectory(agentPresets) {
   const preset = await agentPresets.resolve(CORDIS_PRESET_ID)
-  if (typeof preset?.path !== 'string' || !isAbsolute(preset.path)) {
-    throw new Error('ptc-plus: DSH cordis preset did not expose an absolute composition path')
-  }
   if (typeof preset.broken === 'string' && preset.broken.length > 0) {
     throw new Error(`ptc-plus: DSH cordis preset is unavailable: ${preset.broken}`)
   }
+  // The generations that discover presets from their composition directories
+  // publish an absolute path, and the preset's sibling `skills` directory is
+  // then the companion Skill root. A generation that declares presets without
+  // any composition path publishes no root through this surface at all, so the
+  // report names that missing publication instead of claiming a shape failure
+  // on a healthy host. A published path that is not absolute is still a
+  // contract contradiction.
+  if (preset?.path === undefined) {
+    throw new Error('ptc-plus: the installed DSH agentPresets generation publishes no composition path for the "cordis" preset, so it does not publish the companion Skill root that cordisToolsEnabled mounts')
+  }
+  if (typeof preset.path !== 'string' || !isAbsolute(preset.path)) {
+    throw new Error('ptc-plus: DSH cordis preset did not expose an absolute composition path')
+  }
   return join(dirname(preset.path), 'skills')
 }
 
@@ -329,6 +339,7 @@ export function createCordisToolsOwner(
 
   const installAgent = (agent) => {
     if (disposed) return Promise.resolve()
+    if (withdrawn.has(agent)) return Promise.resolve()
     const mounted = mounts.get(agent)
     if (mounted !== undefined) {
       return mounted.withdrawn === true ? Promise.resolve() : mounted.activation
@@ -416,11 +427,11 @@ export function createCordisToolsOwner(
   /**
    * 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.
+   * The public host lifecycle 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
@@ -451,8 +462,7 @@ export function createCordisToolsOwner(
       if (disposed) return
       for (const agent of [...pending]) {
         void Promise.resolve().then(() => installAgent(agent)).catch(error => {
-          pending.delete(agent)
-          ctx.logger?.warn?.('ptc-plus: deferred Cordis activation failed', error)
+          withdraw(agent, error)
         })
       }
     })

package/internal/dynamic-environment-integration.js

@@ -34,15 +34,19 @@ export function adaptDynamicCell(code, sourceMap, options) {
   let setup
   if (options.module === true) {
     const runtimeUrl = new URL('./dynamic-environment-runtime.js', import.meta.url)
+    const interfaceOwner = allocate('dynamic_interface_owner')
+    const runtimeOptions = `{interfaceOwner:${interfaceOwner}${options.importOperation === undefined
+      ? '' : `,importModule:${options.importOperation}`}}`
     if (options.sourceType === 'module') {
       const factory = allocate('dynamic_factory')
-      setup = `\nimport {createDynamicEnvironmentRuntime as ${factory}} from ${JSON.stringify(runtimeUrl.href)};\n`
-      expression = `${factory}(${options.importOperation === undefined ? '' : `{importModule:${options.importOperation}}`}).installIntrinsics().environment({strict:true,getThis:()=>void 0})`
-      options = { ...options, internalBindings: new Set([...options.internalBindings ?? [], factory]) }
+      setup = `\nimport {createDynamicEnvironmentRuntime as ${factory}} from ${JSON.stringify(runtimeUrl.href)};\nfunction ${interfaceOwner}(){}\n`
+      expression = `${factory}(${runtimeOptions}).installIntrinsics().environment({strict:true,getThis:()=>void 0})`
+      options = { ...options, internalBindings: new Set([...options.internalBindings ?? [], factory, interfaceOwner]) }
     } else {
       const names = ['exports', 'module', 'require', '__filename', '__dirname', 'arguments']
       const bindings = names.map(name => `[${JSON.stringify(name)},{kind:"param",get:()=>${name}${name === 'arguments' && strict ? '' : `,set:v=>${name}=v`}}]`).join(',')
-      setup = `\nconst ${environmentName}=${commonJsCompilerImport(runtimeUrl)}.createDynamicEnvironmentRuntime(${options.importOperation === undefined ? '' : `{importModule:${options.importOperation}}`}).installIntrinsics().environment({strict:${strict},getThis:()=>this,getNewTarget:()=>new.target,allowNewTarget:true,nativeBindings:[${bindings}]});\n`
+      setup = `\nfunction ${interfaceOwner}(){}\nconst ${environmentName}=${commonJsCompilerImport(runtimeUrl)}.createDynamicEnvironmentRuntime(${runtimeOptions}).installIntrinsics().environment({strict:${strict},getThis:()=>this,getNewTarget:()=>new.target,allowNewTarget:true,nativeBindings:[${bindings}]});\n`
+      options = { ...options, internalBindings: new Set([...options.internalBindings ?? [], interfaceOwner]) }
     }
   } else setup = options.nativeRoot === true ? `\nconst ${environmentName}=${options.environmentGlobal};\n`
     : `\nconst ${environmentName}=${options.rootRuntime}.dynamic();\n`

package/internal/dynamic-environment-runtime.js

@@ -16,6 +16,17 @@ function captureReflection(reflect) {
   return captured
 }
 const defaultIntrinsics = { intrinsicEval: eval, realmFunction: Function, globalObject: globalThis, reflect: captureReflection(Reflect) }
+let programAmbientResolver
+
+/** Install the worker-owned resolver used by explicitly adapted program modules. */
+export function installProgramAmbientResolver(resolve) {
+  if (programAmbientResolver !== undefined) throw new Error('program ambient resolver is already installed')
+  if (typeof resolve !== 'function') throw new TypeError('program ambient resolver must be a function')
+  programAmbientResolver = resolve
+  return () => {
+    if (programAmbientResolver === resolve) programAmbientResolver = undefined
+  }
+}
 
 const isObject = value => value !== null && (typeof value === 'object' || typeof value === 'function')
 const isMap = types.isMap
@@ -45,7 +56,7 @@ const asBindings = value => {
 export function createDynamicEnvironmentRuntime({
   importModule = (source, options) => import(source, options),
   intrinsicEval = defaultIntrinsics.intrinsicEval, realmFunction = defaultIntrinsics.realmFunction, globalObject = defaultIntrinsics.globalObject,
-  errors, reflect = defaultIntrinsics.reflect, object, interfaceOwner,
+  errors, reflect = defaultIntrinsics.reflect, object, interfaceOwner, resolveAmbient = programAmbientResolver,
 } = {}) {
   const intrinsics = captureCompilerIntrinsics(realmFunction)
   const { unscopables, Object: intrinsicObject, array: internalArray } = intrinsics
@@ -143,7 +154,10 @@ export function createDynamicEnvironmentRuntime({
       return deleted
     },
   }, object, strict)
-  const ambientReference = (name, strict) => reference(name, {
+  const ambientReference = (name, strict) => {
+    const resolved = resolveAmbient?.(name)
+    if (resolved !== undefined) return reference(name, resolved, undefined, strict)
+    return reference(name, {
     get() {
       if (!reflect.has(globalObject, name)) throw new errors.ReferenceError(`${name} is not defined`)
       return reflect.get(globalObject, name, globalObject)
@@ -154,7 +168,8 @@ export function createDynamicEnvironmentRuntime({
     },
     typeof: () => reflect.has(globalObject, name) ? typeof reflect.get(globalObject, name, globalObject) : 'undefined',
     delete: () => reflect.deleteProperty(globalObject, name),
-  }, undefined, strict)
+    }, undefined, strict)
+  }
 
   function environment({ frames = [], varFrame = new internal.Map(), strict = false, origin, lexicalContext = {},
     getThis = () => globalObject, getNewTarget = () => undefined, allowNewTarget = false,
@@ -170,6 +185,12 @@ export function createDynamicEnvironmentRuntime({
       importModule,
       internalArray,
       expose: nativeCalls.exposedValue,
+      exposeProperty(receiver, key) {
+        if (receiver === null || receiver === undefined) {
+          throw new errors.TypeError(`Cannot read properties of ${receiver}`)
+        }
+        return nativeCalls.exposedMemberValue(receiver, reflect.get(object(receiver), key, receiver))
+      },
       prepareCall: nativeCalls.prepareCall,
       prepareInvocation: nativeCalls.prepareInvocation,
       releaseMemberReceiver: nativeCalls.releaseMemberReceiver,

package/internal/dynamic-native-calls.js

@@ -42,7 +42,10 @@ export function rewriteNativeCalls(tree, environment, { origin, skip, operations
       parent.node.computed = true
       parent.node.key = t.stringLiteral(path.node.name)
     }
-    path.replaceWith(t.inherits(helper('expose', [path.node]), path.node))
+    if (path.isMemberExpression() && !t.isSuper(path.node.object) && !t.isPrivateName(path.node.property)) {
+      const key = path.node.computed ? path.node.property : t.stringLiteral(path.node.property.name)
+      path.replaceWith(t.inherits(helper('exposeProperty', [path.node.object, key]), path.node))
+    } else path.replaceWith(t.inherits(helper('expose', [path.node]), path.node))
     path.skip()
   }
   const prepare = (callee, target, optional = false) => {

package/internal/dynamic-native-runtime.js

@@ -11,6 +11,7 @@ const exposedIntrinsics = new internal.WeakMap()
 const sources = createCallableSourceRegistry()
 const callableSources = new internal.WeakMap()
 const callableSourceTargets = new internal.WeakMap()
+const callableInterfaces = new internal.WeakMap()
 const sourceTarget = origin => typeof origin === 'string' ? origin : origin?.target
 const copyArguments = (source, start = 0, result = []) => internal.copyArray(source, start, source.length, result)
 const invocationScopes = new AsyncLocalStorage()
@@ -114,7 +115,19 @@ export function createNativeCallAdapter({ realmFunction, intrinsicEval, reflect,
     internal.weakMapSet(state.callableSources, compiled, source)
     return compiled
   }
-  const exposedValue = value => internal.mapGet(selected.exposed, value) ?? internal.weakMapGet(exposedIntrinsics, value) ?? value
+  const exposedValue = value => {
+    const exposed = internal.mapGet(selected.exposed, value) ?? internal.weakMapGet(exposedIntrinsics, value)
+    if (exposed !== undefined) return exposed
+    if (typeof value === 'function' && !internal.weakMapHas(callableInterfaces, value)) {
+      internal.weakMapSet(callableInterfaces, value, selected)
+    }
+    return value
+  }
+  const exposedMemberValue = (receiver, value) => {
+    const owner = typeof receiver === 'function' ? internal.weakMapGet(callableInterfaces, receiver) : undefined
+    const exposed = owner === undefined ? undefined : internal.mapGet(owner.exposed, value)
+    return exposed ?? exposedValue(value)
+  }
   const propagate = (error, origin) => {
     recordExceptionOrigin(error, sourceTarget(origin), { reset: true })
     for (let scope = currentScope(); scope !== undefined; scope = scope.parent) {
@@ -218,6 +231,7 @@ export function createNativeCallAdapter({ realmFunction, intrinsicEval, reflect,
   return {
     install,
     exposedValue,
+    exposedMemberValue,
     isEval: callee => callee === state.intrinsicEval || internal.mapHas(selected.exposed, state.intrinsicEval) && callee === internal.mapGet(selected.exposed, state.intrinsicEval),
     evaluate(compiled, environment) {
       // Bootstrap originals never leave this owner. Direct eval must use the