dsh-ptc-plus 0.3.1 → 0.4.1

package/internal/failure-reporting.js

@@ -1,27 +1,103 @@
 import { diagnostic } from './diagnostic.js'
+import { AsyncLocalStorage } from 'node:async_hooks'
+import { createHash } from 'node:crypto'
+import { moduleRuntimeIntrinsics as internal } from './compiler-intrinsics.js'
 
 export const MAX_ERROR_LOG_BYTES = 4 * 1024
 export const FAILURE_HINT_THRESHOLD = 3
 export const LONG_CELL_CODE_UNITS = 2_000
 const BINDING_FAILURE = Symbol('binding failure')
+const PROGRAM_FAILURES = new internal.WeakMap()
+const MAX_CAUSE_CODE_UNITS = 2048
+const exceptionOrigins = new AsyncLocalStorage()
+const runExceptionScope = exceptionOrigins.run.bind(exceptionOrigins)
+const currentExceptionScope = exceptionOrigins.getStore.bind(exceptionOrigins)
 
-export function markBindingFailure(error) {
-  Object.defineProperty(error, BINDING_FAILURE, { value: true })
+/** Propagation facts belong to one execution, never to a user-thrown value. */
+export function createExceptionOriginScope() {
+  const state = { origins: new internal.Map(), sourceFailures: new internal.Set(), open: true }
+  return {
+    run: callback => runExceptionScope(state, callback),
+    origins: error => internal.mapGet(state.origins, error),
+    sourceFailure: error => internal.setHas(state.sourceFailures, error),
+    close() { state.open = false; internal.mapClear(state.origins); internal.setClear(state.sourceFailures) },
+  }
+}
+
+export function recordExceptionOrigin(error, origin, { reset = false, sourceFailure = false } = {}) {
+  const state = currentExceptionScope()
+  if (state?.open !== true) return
+  if (reset) { internal.mapDelete(state.origins, error); internal.setDelete(state.sourceFailures, error) }
+  if (sourceFailure) internal.setAdd(state.sourceFailures, error)
+  if (typeof origin !== 'string') return
+  const origins = internal.mapGet(state.origins, error) ?? []
+  if (!internal.includes(origins, origin)) internal.appendArray(origins, origin)
+  internal.mapSet(state.origins, error, origins)
+}
+
+const SOURCE_LINE_BREAK = /\r\n|[\n\r\u2028\u2029]/
+const sourceLines = source => source.split(SOURCE_LINE_BREAK)
+
+/** A cell position is a 1-based line and column inside its source. The column
+ * may address the position just after the last character of a line. */
+function boundedPosition(position, lines) {
+  if (position === null || typeof position !== 'object'
+    || !Number.isSafeInteger(position.line) || position.line < 1
+    || !Number.isSafeInteger(position.column) || position.column < 1
+    || position.line > lines.length || position.column > lines[position.line - 1].length + 1) return undefined
+  return { line: position.line, column: position.column }
+}
+
+/** Validate a candidate against the source that owns the reported cell. */
+export function cellPosition(position, source) {
+  return boundedPosition(position, sourceLines(source))
+}
+
+/** Only a fact belonging to the current original source can bypass its map. */
+export function exceptionOriginPosition(origins, source) {
+  if (!Array.isArray(origins)) return undefined
+  const prefix = `eval:${createHash('sha256').update(source).digest('hex')}:`
+  const lines = sourceLines(source)
+  for (const origin of origins) {
+    if (typeof origin !== 'string' || !origin.startsWith(prefix)) continue
+    const match = /^(\d+):(\d+)$/.exec(origin.slice(prefix.length))
+    if (match === null) continue
+    const position = boundedPosition({ line: Number(match[1]), column: Number(match[2]) }, lines)
+    if (position !== undefined) return position
+  }
+  return undefined
+}
+
+export function markBindingFailure(error, kind = 'lexical') {
+  Object.defineProperty(error, BINDING_FAILURE, { value: kind })
   return error
 }
 
-function repeatedFailureDiagnostic(kind, streak) {
-  if (kind === 'binding') {
+/** Preserve worker-owned failure identity without trusting user exception text. */
+export function programBindingError(kind, message) {
+  const error = new internal.Error(message)
+  internal.weakMapSet(PROGRAM_FAILURES, error, kind)
+  return error
+}
+
+function repeatedFailureDiagnostic(kind, streak, stateEffect) {
+  if (kind === 'lexical' || kind === 'capability') {
+    const capability = kind === 'capability'
     return diagnostic({
       code: 'PTC-W001',
       severity: 'warning',
       phase: 'execute',
-      message: `this cell failed ${streak} times with the same binding error; inspect the live binding names and change the expression before retrying`,
-      stateEffect: 'unchanged',
-      help: [
+      message: `this cell failed ${streak} times with the same ${capability ? 'capability' : 'lexical binding'} error; resolve the reported name before continuing`,
+      stateEffect,
+      cause: { code: capability ? 'PTC-CAPABILITY' : 'PTC-LOCAL', message: capability ? 'current program capability lookup failed' : 'local name or declaration conflict' },
+      help: capability ? [
         'inspect live bindings with capabilities.tree(), capabilities.find(), or capabilities.inspect()',
         'call available typed members through tools.*',
         'do not repeat the same unresolved binding expression',
+      ] : [
+        'inspect the visible cell source and results for the local declaration, scope, or initialization failure',
+        'correct the name or initialization; use a fresh name or block for a declaration conflict',
+        'capabilities describes program APIs, not session-local variables; discovery cannot prove local state',
       ],
     })
   }
@@ -30,7 +106,7 @@ function repeatedFailureDiagnostic(kind, streak) {
     severity: 'warning',
     phase: 'execute',
     message: `this cell failed ${streak} times with the same error; inspect the reported cause and change the approach before retrying`,
-    stateEffect: 'unchanged',
+    stateEffect,
     help: ['inspect the reported cause', 'change the inputs or approach before retrying'],
   })
 }
@@ -54,6 +130,13 @@ export function messageOf(error, fallback = 'Unprintable error') {
   }
 }
 
+/** Preserve the child-process exit facts in every helper failure diagnostic. */
+export function processExitDescription(code, signal) {
+  return signal === null || signal === undefined
+    ? `code ${code}`
+    : `code ${code}, signal ${signal}`
+}
+
 export function firstLine(value, fallback = undefined) {
   if (typeof value !== 'string') return fallback
   const line = value.split(/[\r\n]/, 1)[0]
@@ -92,18 +175,26 @@ export function limitLogs(logs) {
   return tail
 }
 
-export function errorPosition(error, filename) {
+/** A frame is only useful when its 1-based line and column are safe integers. */
+function structuralPosition(position) {
+  return Number.isSafeInteger(position.line) && position.line >= 1
+    && Number.isSafeInteger(position.column) && position.column >= 1 ? position : undefined
+}
+
+/** Extract the first frame for the active cell. The frame is reported in the
+ * executed text, so it is only a cell position when it lies inside the source
+ * that produced that text. */
+export function errorPosition(error, filename, source) {
   const stack = safeProperty(error, 'stack')
   if (typeof stack !== 'string') return undefined
   const escaped = filename.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
   const match = new RegExp(`${escaped}:(\\d+):(\\d+)`).exec(stack)
   if (match === null) return undefined
-  const line = Number(match[1])
-  const column = Number(match[2])
-  return line >= 1 && column >= 1 ? { line, column } : undefined
+  const position = { line: Number(match[1]), column: Number(match[2]) }
+  return source === undefined ? structuralPosition(position) : cellPosition(position, source)
 }
 
-export function errorDetails(error, filename) {
+export function errorDetails(error, filename, source) {
   const message = messageOf(error, 'Unprintable thrown value')
   const rawName = safeProperty(error, 'name')
   const name = typeof rawName === 'string' && rawName.length > 0 ? rawName : 'Error'
@@ -114,19 +205,28 @@ export function errorDetails(error, filename) {
   const candidate = safeProperty(error, 'ptcCause')
   const causeMessage = firstLine(safeProperty(candidate, 'message'))
   const causeCode = firstLine(safeProperty(candidate, 'code'))
+  const stderr = safeProperty(error, 'stderr')
+  const stderrText = typeof stderr === 'string' ? stderr.slice(0, MAX_CAUSE_CODE_UNITS)
+    : Buffer.isBuffer(stderr) ? stderr.subarray(0, MAX_CAUSE_CODE_UNITS).toString('utf8') : ''
+  const boundedMessage = message.slice(0, MAX_CAUSE_CODE_UNITS)
+  const continuation = boundedMessage.search(/[\r\n]/)
+  const detail = [continuation < 0 ? '' : boundedMessage.slice(continuation + 1), stderrText]
+    .join(' ').slice(0, MAX_CAUSE_CODE_UNITS).replace(/\s+/g, ' ').trim()
   const cause = causeMessage === undefined
-    ? undefined
+    ? detail.length === 0 ? undefined : { message: detail }
     : {
         ...(causeCode === undefined ? {} : { code: causeCode }),
         message: causeMessage,
       }
-  const position = errorPosition(error, filename)
+  const position = errorPosition(error, filename, source)
+  const failureOrigin = internal.weakMapGet(PROGRAM_FAILURES, error)
   return {
     name,
     message,
     ...(toolName === undefined ? {} : { toolName }),
     ...(position === undefined ? {} : { position }),
     ...(cause === undefined ? {} : { cause }),
+    ...(failureOrigin === undefined ? {} : { failureOrigin }),
   }
 }
 
@@ -140,16 +240,16 @@ export function createFailureTracker() {
       kind = undefined
       streak = 0
     },
-    hint(error) {
+    hint(error, stateEffect = 'unknown') {
       const nextFingerprint = `${error.kind}\u0000${error.message}`
       if (fingerprint === nextFingerprint) streak += 1
       else {
         fingerprint = nextFingerprint
-        kind = error[BINDING_FAILURE] === true ? 'binding' : 'generic'
+        kind = error[BINDING_FAILURE] ?? 'generic'
         streak = 1
       }
       if (streak !== FAILURE_HINT_THRESHOLD) return undefined
-      return repeatedFailureDiagnostic(kind, streak)
+      return repeatedFailureDiagnostic(kind, streak, stateEffect)
     },
   })
 }

package/internal/host-rpc.js

@@ -0,0 +1,66 @@
+import { bindTypertRemote } from '@deepseek-ai/dsh-typert-protocol'
+import { rpcDescriptor } from './rpc-contract.js'
+
+/** Own Remote services and the package's Host invocation contribution. */
+export function createHostRpc(ctx) {
+  const handlers = new Map()
+  let provider
+  let definition
+  let epoch
+  let disposed = false
+  const publish = () => {
+    // Registry withdrawal is synchronous, so replacement has no overlapping endpoints.
+    definition?.()
+    definition = undefined
+    if (provider === undefined || disposed || handlers.size === 0) return
+    definition = provider.effect(() => provider.typert.register({
+      package: 'dsh-ptc-plus', face: 'host', schemas: [],
+      model: { services: [], events: [], objects: [] },
+      invocations: [...handlers.keys()].map(rpcDescriptor),
+    }), 'ptc-plus: Remote definitions')
+  }
+  const port = {
+    register(contract, handler) {
+      if (disposed) throw new Error('PTC Plus RPC owner is disposed')
+      if (handlers.has(contract)) throw new Error(`PTC Plus RPC service ${contract.service} is already registered`)
+      const lifetime = new AbortController()
+      const service = {
+        invoke(operation, payload, signal) {
+          lifetime.signal.throwIfAborted()
+          if (epoch === undefined) throw new Error('PTC Plus RPC provider is unavailable')
+          return handler(operation, payload, AbortSignal.any([signal, lifetime.signal, epoch.signal]))
+        },
+      }
+      service.typertRemote = bindTypertRemote(service, contract.service)
+      const release = ctx.effect(function* () {
+        yield ctx.provide(contract.service, service)
+        handlers.set(contract, { release: () => release() })
+        yield () => {
+          lifetime.abort()
+          handlers.delete(contract)
+          publish()
+        }
+        publish()
+      }, 'ptc-plus: Remote service')
+      return release
+    },
+  }
+  const injection = ctx.inject?.(['typert'], scope => {
+    provider = scope
+    epoch = new AbortController()
+    publish()
+    scope.effect(() => scope.provide('ptcPlusRpc', port), 'ptc-plus: RPC registration port')
+    scope.effect(() => () => {
+      epoch.abort()
+      epoch = undefined
+      provider = undefined
+      definition = undefined
+    }, 'ptc-plus: RPC provider lifetime')
+  })
+  return { async dispose() {
+    disposed = true
+    for (const entry of [...handlers.values()]) await entry.release()
+    if (typeof injection === 'function') await injection()
+    else await injection?.dispose()
+  } }
+}