dsh-ptc-plus 0.3.2 → 0.4.2

package/internal/binding-update-policy.js

@@ -0,0 +1,72 @@
+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
+ * by the compiler and journal.  Keeping this mapping in one owner prevents
+ * individual lowering paths from combining legacy switches differently.
+ */
+export function executionPolicies(config, replayRecord = undefined) {
+  if (config.bindingUpdates !== undefined && !['stateful', 'protected'].includes(config.bindingUpdates)) {
+    throw new TypeError('ptc-plus: bindingUpdates must be stateful or protected')
+  }
+  if (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,
+      moduleTransform: normalizeModuleTransform(replayRecord.moduleTransform, languageSemantics),
+      bindingPolicy,
+      rewritesEnabled,
+      moduleSemantics,
+    })
+  }
+  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,
+    })
+  }
+  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.
+      rewritesEnabled: Object.freeze({ autoRewriteImports: true, autoStripExports: true, autoSplitRedeclarations: true }),
+      moduleSemantics: LIVE_MODULE_SEMANTICS,
+    })
+  }
+  return Object.freeze({
+    languageSemantics: LEGACY_LANGUAGE_SEMANTICS,
+    moduleTransform: moduleTransformForLanguage(LEGACY_LANGUAGE_SEMANTICS),
+    bindingPolicy: Object.freeze({
+      variableRedeclarations: config.looseTopLevelRedeclarations === true,
+      functionClassRedeclarations: config.looseTopLevelFunctionClassRedeclarations === true,
+    }),
+    rewritesEnabled: Object.freeze({
+      autoRewriteImports: config.autoRewriteImports === true,
+      autoStripExports: config.autoStripExports === true,
+      autoSplitRedeclarations: config.autoSplitRedeclarations === true,
+    }),
+    moduleSemantics: LIVE_MODULE_SEMANTICS,
+  })
+}
+
+/** Stable prose inputs for the model-visible REPL guidance. */
+export function guidancePolicies(config) {
+  const policies = executionPolicies(config)
+  return Object.freeze({
+    ...policies,
+    durableReplay: config.durableReplay === true,
+    cordisToolsEnabled: config.cordisToolsEnabled === true,
+  })
+}

package/internal/bounded-worker-round.js

@@ -0,0 +1,56 @@
+/** How a bounded worker round ended without a result. */
+export const ROUND_TIMEOUT = 'timeout'
+export const ROUND_CANCELLED = 'cancelled'
+export const ROUND_OUTPUT_LIMIT = 'output-limit'
+
+/**
+ * Own one bounded worker round: captured output bytes, the wall-clock deadline,
+ * cancellation and a single settlement. Worker creation, retention and
+ * termination stay with the caller, which is told exactly once how the round
+ * ended through `settle({ ok: true, result })` or `settle({ ok: false, reason })`.
+ */
+export function createBoundedWorkerRound({ maxOutputBytes, maxWallMs, signal, settle }) {
+  const logs = []
+  let capturedBytes = 0
+  let ended = false
+  const end = (outcome) => {
+    if (ended) return false
+    ended = true
+    clearTimeout(timer)
+    signal?.removeEventListener('abort', abort)
+    settle(outcome)
+    return true
+  }
+  const fail = reason => end({ ok: false, reason })
+  const abort = () => { fail(ROUND_CANCELLED) }
+  const timer = setTimeout(() => fail(ROUND_TIMEOUT), maxWallMs)
+  signal?.addEventListener('abort', abort, { once: true })
+  if (signal?.aborted === true) fail(ROUND_CANCELLED)
+  return Object.freeze({
+    logs,
+    /** Record one stream chunk; ends the round when the byte budget is exceeded. */
+    capture(channel, text) {
+      if (ended) return
+      capturedBytes += Buffer.byteLength(text, 'utf8')
+      if (capturedBytes > maxOutputBytes) { fail(ROUND_OUTPUT_LIMIT); return }
+      logs.push({ channel, text })
+    },
+    /**
+     * True when the byte budget is spent.
+     *
+     * `envelope` measures the object the caller returns with the captured `logs`
+     * included as a member, so log wrappers and JSON escaping count against the
+     * same budget; that is the candidate run's returned-envelope budget. Without
+     * it the raw captured bytes plus the serialized payload are measured, which is
+     * the workbench console's output budget.
+     */
+    exceeds(payload, { envelope = false } = {}) {
+      if (envelope) {
+        return Buffer.byteLength(JSON.stringify({ ...payload, logs }), 'utf8') > maxOutputBytes
+      }
+      return capturedBytes + Buffer.byteLength(JSON.stringify(payload), 'utf8') > maxOutputBytes
+    },
+    succeed(result) { return end({ ok: true, result }) },
+    fail,
+  })
+}

package/internal/callable-definition-environment.js

@@ -0,0 +1,42 @@
+import { types as t } from '@babel/core'
+import traverseImport from '@babel/traverse'
+
+const traverse = traverseImport.default ?? traverseImport
+
+/** Parameters and computed keys evaluate before a callable body scope exists.
+ * Return that callable's path; an intervening callable body owns its own scope. */
+export function callableDefinitionOwner(path) {
+  let child = path
+  while (child.parentPath && !child.parentPath.isFunction()) child = child.parentPath
+  return child.parentPath && child.key !== 'body' ? child.parentPath : undefined
+}
+
+/** Close definition helpers without losing surrounding suspension or lexical
+ * this/new.target. The outer owner only supports Babel's arrow conversion. */
+export function closeDefinitionExpression(helpers, value, parameters = [], argumentsList = []) {
+  const body = t.blockStatement([...helpers, t.returnStatement(value)])
+  const factory = t.arrowFunctionExpression(parameters, body)
+  const owner = t.functionExpression(null, [], t.blockStatement([t.returnStatement(factory)]))
+  const tree = t.file(t.program([t.expressionStatement(owner)]))
+  let awaited = false, yielded = false
+  traverse(tree, { ArrowFunctionExpression(path) {
+    if (path.node !== factory) return
+    path.get('body').traverse(traverse.visitors.environmentVisitor({
+      ArrowFunctionExpression(path) { path.skip() },
+      AwaitExpression() { awaited = true },
+      YieldExpression() { yielded = true },
+    }))
+    factory.async = awaited
+    if (yielded) {
+      const converted = path.arrowFunctionToExpression()
+      converted.node.generator = true
+    }
+    path.stop()
+  } })
+  if (yielded) {
+    owner.type = 'ArrowFunctionExpression'
+    return t.yieldExpression(t.callExpression(t.callExpression(owner, []), argumentsList), true)
+  }
+  const expression = t.callExpression(factory, argumentsList)
+  return awaited ? t.awaitExpression(expression) : expression
+}

package/internal/callable-source-catalog.js

@@ -0,0 +1,129 @@
+import { hashText, inflateText } from './compiler-service.js'
+import { moduleCompilerIntrinsics, moduleRuntimeIntrinsics as internal } from './compiler-intrinsics.js'
+import { CALLABLE_SOURCE_FORMAT as FORMAT, CALLABLE_SOURCE_BLOCK_UNITS as BLOCK_UNITS } from './callable-source-format.js'
+
+export { createCallableSourceCatalog } from './compiler-service.js'
+
+const CACHED_BLOCKS = 8
+const sourceKey = source => `${source.length}:${hashText(source, 'utf16le', 'base64')}`
+
+function catalogKey(catalog) {
+  let text = ''
+  for (let index = 0; index < catalog.buffers.length; index++) {
+    const buffer = catalog.buffers[index]
+    text += `${buffer.length}:`
+    for (let block = 0; block < buffer.blocks.length; block++) {
+      text += `${buffer.blocks[block]};`
+    }
+  }
+  for (let index = 0; index < catalog.entries.length; index++) {
+    const entry = catalog.entries[index]
+    for (let item = 0; item < entry.length; item++) text += `${entry[item]}:`
+    text += ';'
+  }
+  return hashText(text)
+}
+
+function sameCatalog(left, right) {
+  if (left.buffers.length !== right.buffers.length || left.entries.length !== right.entries.length) return false
+  for (let index = 0; index < left.buffers.length; index++) {
+    const a = left.buffers[index], b = right.buffers[index]
+    if (a.length !== b.length || a.blocks.length !== b.blocks.length) return false
+    for (let block = 0; block < a.blocks.length; block++) if (a.blocks[block] !== b.blocks[block]) return false
+  }
+  for (let index = 0; index < left.entries.length; index++) {
+    const a = left.entries[index], b = right.entries[index]
+    if (a.length !== b.length) return false
+    for (let item = 0; item < a.length; item++) if (a[item] !== b[item]) return false
+  }
+  return true
+}
+
+/** Digests select candidates; only an exact native-source comparison owns reflection. */
+export function createCallableSourceRegistry() {
+  const literals = new internal.Map()
+  const catalogs = new internal.Map()
+  const candidates = new internal.Map()
+  const decoded = new internal.Map()
+  let ordinal = 0
+  const blockText = encoded => {
+    let text = internal.mapGet(decoded, encoded)
+    if (text === undefined) {
+      text = inflateText(encoded, BLOCK_UNITS * 2)
+      internal.mapSet(decoded, encoded, text)
+      if (internal.mapSize(decoded) > CACHED_BLOCKS) internal.mapDelete(decoded, internal.mapFirstKey(decoded))
+    }
+    return text
+  }
+  const visitParts = (catalog, bufferIndex, start, end, visit) => {
+    const buffer = catalog.buffers[bufferIndex]
+    while (start < end) {
+      const index = internal.floor(start / BLOCK_UNITS)
+      const offset = start % BLOCK_UNITS
+      const length = internal.min(end - start, BLOCK_UNITS - offset)
+      if (visit(internal.sliceString(blockText(buffer.blocks[index]), offset, offset + length)) === false) return false
+      start += length
+    }
+  }
+  const matches = (catalog, entry, native) => {
+    let offset = 0
+    const complete = visitParts(catalog, entry[0], entry[1], entry[2], text => {
+      if (!internal.startsWith(native, text, offset)) return false
+      offset += text.length
+    })
+    return complete !== false && offset === native.length
+  }
+  return {
+    register(sources) {
+      const current = ++ordinal
+      if (internal.isArray(sources)) {
+        for (let index = 0; index < sources.length; index++) {
+          const entry = sources[index]
+          internal.mapSet(literals, entry[0], { original: entry[1], ordinal: current })
+        }
+        return
+      }
+      if (sources.format !== FORMAT) throw new moduleCompilerIntrinsics.TypeError('unsupported callable source catalog')
+      const key = catalogKey(sources)
+      let bucket = internal.mapGet(catalogs, key)
+      if (bucket === undefined) internal.mapSet(catalogs, key, bucket = [])
+      for (let index = 0; index < bucket.length; index++) {
+        const registration = bucket[index]
+        if (!sameCatalog(registration.catalog, sources)) continue
+        registration.ordinal = current
+        return
+      }
+      // Compiler transport values may be reused by their caller. Snapshot the
+      // compressed facts without retaining caller-owned mutable containers.
+      const catalog = { buffers: [], entries: [] }
+      for (let index = 0; index < sources.buffers.length; index++) {
+        const buffer = sources.buffers[index]
+        internal.appendArray(catalog.buffers, { length: buffer.length, blocks: internal.copyArray(buffer.blocks) })
+      }
+      for (let index = 0; index < sources.entries.length; index++) internal.appendArray(catalog.entries, internal.copyArray(sources.entries[index]))
+      const registration = { catalog, ordinal: current }
+      internal.appendArray(bucket, registration)
+      for (let index = 0; index < catalog.entries.length; index++) {
+        const entry = catalog.entries[index]
+        let entries = internal.mapGet(candidates, entry[6])
+        if (entries === undefined) internal.mapSet(candidates, entry[6], entries = [])
+        internal.appendArray(entries, { registration, entry })
+      }
+    },
+    get(native) {
+      let found = internal.mapGet(literals, native)
+      const entries = internal.mapGet(candidates, sourceKey(native))
+      if (entries !== undefined) for (let index = 0; index < entries.length; index++) {
+        const { registration, entry } = entries[index]
+        if (found !== undefined && found.ordinal > registration.ordinal) continue
+        if (matches(registration.catalog, entry, native)) found = { ...registration, entry }
+      }
+      if (found === undefined) return undefined
+      if (found.original !== undefined) return found.original
+      const entry = found.entry
+      let original = ''
+      visitParts(found.catalog, entry[3], entry[4], entry[5], text => { original += text })
+      return original
+    },
+  }
+}

package/internal/callable-source-encoding.js

@@ -0,0 +1,47 @@
+import { hashText, deflateText } from './compiler-text.js'
+import { CALLABLE_SOURCE_FORMAT as FORMAT, CALLABLE_SOURCE_BLOCK_UNITS as BLOCK_UNITS } from './callable-source-format.js'
+
+/** Keep windows around referenced callables. Neighbors share compression
+ * blocks; unrelated large data regions stay outside the reflection catalog. */
+export function createCallableSourceCatalog(buffers, ranges) {
+  const selected = buffers.map(() => [])
+  const entries = ranges.map(range => [...range])
+  for (let index = 0; index < ranges.length; index++) {
+    const range = ranges[index]
+    for (const offset of [0, 3]) {
+      const source = buffers[range[offset]]
+      const start = range[offset + 1], end = range[offset + 2]
+      if (typeof source !== 'string' || !Number.isInteger(start) || !Number.isInteger(end)
+        || start < 0 || end < start || end > source.length) throw new TypeError('invalid callable source range')
+      selected[range[offset]].push({ start, end, index, offset })
+    }
+    const source = buffers[range[0]].slice(range[1], range[2])
+    entries[index].push(`${source.length}:${hashText(source, 'utf16le', 'base64')}`)
+  }
+  const encoded = []
+  for (let index = 0; index < selected.length; index++) {
+    const intervals = []
+    for (const item of selected[index].sort((left, right) => left.start - right.start || right.end - left.end)) {
+      let interval = intervals.at(-1)
+      if (interval === undefined || item.start - interval.end > BLOCK_UNITS) {
+        interval = { start: item.start, end: item.end, items: [] }
+        intervals.push(interval)
+      }
+      interval.end = Math.max(interval.end, item.end)
+      interval.items.push(item)
+    }
+    for (const interval of intervals) {
+      const source = buffers[index].slice(interval.start, interval.end)
+      const blocks = []
+      for (let start = 0; start < source.length; start += BLOCK_UNITS) blocks.push(deflateText(source.slice(start, start + BLOCK_UNITS)))
+      for (const item of interval.items) {
+        const entry = entries[item.index]
+        entry[item.offset] = encoded.length
+        entry[item.offset + 1] -= interval.start
+        entry[item.offset + 2] -= interval.start
+      }
+      encoded.push({ length: source.length, blocks })
+    }
+  }
+  return { format: FORMAT, length: entries.length, buffers: encoded, entries }
+}