dsh-ptc-plus 0.4.2 → 0.4.8

package/internal/session-runtime.js

@@ -4,6 +4,7 @@ import { diagnostic, renderDiagnostic } from './diagnostic.js'
 import { createFailureTracker, messageOf } from './failure-reporting.js'
 import {
   createJournal,
+  isCanonicalSequence,
   liveToolCallSeq,
   normalizeJournal,
   reduceStateOperations,
@@ -29,6 +30,17 @@ import {
 } from './repl-memory-projection.js'
 
 const WORKER_URL = new URL('./kernel-worker.js', import.meta.url)
+const UNAVAILABLE_SURFACE_GENERATION = Symbol('unavailableSurfaceGeneration')
+
+function surfaceGeneration(session, provenanceRequired = true) {
+  try {
+    return session?.surface?.replaceGeneration
+      ?? (provenanceRequired ? UNAVAILABLE_SURFACE_GENERATION : undefined)
+  } catch {
+    return provenanceRequired ? UNAVAILABLE_SURFACE_GENERATION : undefined
+  }
+}
+
 function recoveryDiagnostic(count) {
   return diagnostic({
     code: 'PTC-R002',
@@ -66,20 +78,16 @@ class ReplayCancelled extends Error {
 }
 
 class SessionKernel {
-  constructor({ config, history, cwd, session, userBindingsCwd, withInitiator, observeValues }) {
+  constructor({ config, history, cwd, session, surfaceProvenanceRequired, userBindingsCwd, withInitiator, observeValues }) {
     this.config = config
     this.history = history
     this.initialRecoveryBoundary = recoveryBoundaryForHistory(history)
-    this.surfaceGeneration = undefined
-    try {
-      this.surfaceGeneration = session?.surface?.replaceGeneration
-    } catch {
-      this.surfaceGeneration = undefined
-    }
+    this.surfaceGeneration = surfaceGeneration(session, surfaceProvenanceRequired)
     this.cwd = cwd
     this.userBindingsCwd = userBindingsCwd
     this.observeValues = observeValues
     this.session = session
+    this.surfaceProvenanceRequired = surfaceProvenanceRequired
     this.withInitiator = withInitiator
     this.durability = durabilityState()
     this.bindingCatalog = new BindingCatalog()
@@ -103,10 +111,19 @@ class SessionKernel {
       cwd,
       compilerCache: compilerWorkerCache,
       onMessage: message => this.cellExecutor.onMessage(message),
+      onUnmatchedOutputFailure: message => {
+        const active = this.active
+        if (active === undefined) return false
+        active.resolve({ logs: [], error: { kind: 'worker-exit', message } }, true)
+        return true
+      },
       onFailure: message => {
         this.pendingInspection?.finish()
         this.workerObservation = undefined
-        this.active?.resolve({ logs: [], error: { kind: 'worker-exit', message } }, true)
+        const active = this.active
+        if (active === undefined) return false
+        active.resolve({ logs: [], error: { kind: 'worker-exit', message } }, true)
+        return true
       },
     })
     this.failures = createFailureTracker()
@@ -181,10 +198,10 @@ class SessionKernel {
     const current = () => {
       if (this.disposed || !this.config.replViewEnabled || signal?.aborted
         || this.client.worker === undefined || this.unsettledCells > 0) return false
-      try {
-        return this.session?.surface?.replaceGeneration === this.surfaceGeneration
-          && isDeepStrictEqual(expected, createReplMemorySnapshot(this.bindingCatalog.snapshot()))
-      } catch { return false }
+      return surfaceGeneration(this.session, this.surfaceProvenanceRequired) === this.surfaceGeneration
+        && (!this.surfaceProvenanceRequired
+          || this.surfaceGeneration !== UNAVAILABLE_SURFACE_GENERATION)
+        && isDeepStrictEqual(expected, createReplMemorySnapshot(this.bindingCatalog.snapshot()))
     }
     return new Promise(resolve => {
       let finished = false
@@ -234,13 +251,10 @@ class SessionKernel {
     const finishResult = result => recoveryBoundaries.length === 0
       ? result
       : { ...result, recoveryBoundaries: recoveryBoundaries.map(boundary => ({ ...boundary })) }
-    let currentGeneration
-    try {
-      currentGeneration = this.session?.surface?.replaceGeneration
-    } catch {
-      currentGeneration = undefined
-    }
-    if (currentGeneration !== undefined && currentGeneration !== this.surfaceGeneration) {
+    const currentGeneration = surfaceGeneration(this.session, this.surfaceProvenanceRequired)
+    const hasLiveState = this.liveCallSeqs.size > 0
+    if (this.surfaceProvenanceRequired
+      && (currentGeneration !== this.surfaceGeneration || hasLiveState)) {
       this.surfaceGeneration = currentGeneration
       const visibleCallSeqs = visibleExecutableCallSeqs(this.session)
       const contractsLiveState = [...this.liveCallSeqs].some(callSeq => (
@@ -597,6 +611,7 @@ function sessionOf(sessionContext) {
       callId: undefined,
       persistedCallSeq: undefined,
       cwd: undefined,
+      surfaceProvenanceRequired: false,
     }
   }
   const session = sessionContext.session
@@ -606,6 +621,7 @@ function sessionOf(sessionContext) {
     callId: sessionContext.callId,
     persistedCallSeq: sessionContext.persistedCallSeq,
     cwd: typeof session?.header?.cwd === 'string' ? session.header.cwd : undefined,
+    surfaceProvenanceRequired: true,
   }
 }
 
@@ -657,12 +673,19 @@ export class SessionRuntime {
       return completed({ logs: [], error: { kind: 'exception', message: messageOf(error) } })
     }
     request = { ...request, bindings: bindingDescriptors.namespaces, bindingDescriptors }
-    const { id: sessionId, session, callId, persistedCallSeq, cwd } = sessionOf(sessionContext)
+    const {
+      id: sessionId,
+      session,
+      callId,
+      persistedCallSeq,
+      cwd,
+      surfaceProvenanceRequired,
+    } = sessionOf(sessionContext)
     let callSeq
     let sourceCallSeq
     try {
       if (persistedCallSeq !== undefined
-        && (!Number.isSafeInteger(persistedCallSeq) || persistedCallSeq < 0)) {
+        && !isCanonicalSequence(persistedCallSeq)) {
         throw new Error('persisted tool call sequence must be a non-negative safe integer')
       }
       if (cellConfig.durableReplay) {
@@ -700,6 +723,7 @@ export class SessionRuntime {
         history,
         cwd,
         session,
+        surfaceProvenanceRequired,
         userBindingsCwd: this.userBindingsCwd,
         withInitiator: this.withInitiator,
         observeValues: () => this.config.replViewEnabled && this.observeSession(sessionId),

package/internal/session-state.js

@@ -1,10 +1,12 @@
 // Runtime state transitions shared by the session coordinator and cell executor.
 
 import { userBindingCatalogEntries } from './user-bindings.js'
+import { boundedDefinitionSource } from './repl-memory-projection.js'
 import { LEGACY_USER_BINDINGS_SHADOW_POLICY } from './session-journal-schema.js'
 import { advanceLegacyBindings } from './legacy-binding-catalog.js'
 import { dynamicBindingOrigin } from './dynamic-binding-evidence.js'
 import { LEGACY_LANGUAGE_SEMANTICS, normalizeLanguageSemantics } from './language-semantics.js'
+import { sourceLineStarts, sourceOffsetAtPosition } from './source-position-map.js'
 
 /**
  * Reuse counts belong to a logical binding identity, not to one declaration
@@ -236,7 +238,7 @@ export class BindingCatalog {
           definition: previous?.origin === undefined && previous?.definition !== undefined
             ? previous.definition
             : fact.state === 'local' && typeof source === 'string' && source.length > 0
-              ? Object.freeze({ source: source.slice(0, MAX_DEFINITION_SOURCE_LENGTH), line: 1, column: 1 }) : undefined,
+              ? Object.freeze({ source: boundedDefinitionSource(source), line: 1, column: 1 }) : undefined,
           writable: previous?.writable ?? true,
           userBindingState: fact.state,
           unavailable: fact.state !== 'local',
@@ -290,41 +292,17 @@ function applyRootBindingFacts(entries, facts, rootCandidates, dynamicOrigins, i
   }
 }
 
-const MAX_DEFINITION_SOURCE_LENGTH = 1024
-
-function lineOffsets(source) {
-  const offsets = [0]
-  for (let index = 0; index < source.length; index += 1) {
-    if (source.charCodeAt(index) === 10) offsets.push(index + 1)
-  }
-  return offsets
-}
-
-function offsetAt(offsets, sourceLength, position) {
-  if (position === null || typeof position !== 'object'
-    || !Number.isSafeInteger(position.line) || position.line < 1
-    || !Number.isSafeInteger(position.column) || position.column < 1
-    || position.line > offsets.length) return undefined
-  const lineStart = offsets[position.line - 1]
-  const lineEnd = position.line < offsets.length ? offsets[position.line] - 1 : sourceLength
-  const offset = lineStart + position.column - 1
-  return offset <= lineEnd ? offset : undefined
-}
-
 function sourceDefinitionExtractor(source) {
-  const offsets = typeof source === 'string' ? lineOffsets(source) : undefined
+  const offsets = typeof source === 'string' ? sourceLineStarts(source) : undefined
   const extracted = new Map()
   return span => {
     if (offsets === undefined || span === null || typeof span !== 'object') return undefined
-    const start = offsetAt(offsets, source.length, span)
-    const end = offsetAt(offsets, source.length, span.end)
+    const start = sourceOffsetAtPosition(source, span, offsets)
+    const end = sourceOffsetAtPosition(source, span.end, offsets)
     if (start === undefined || end === undefined || end <= start) return undefined
     const key = `${start}:${end}`
     if (extracted.has(key)) return extracted.get(key)
-    const length = end - start
-    const bounded = length <= MAX_DEFINITION_SOURCE_LENGTH
-      ? source.slice(start, end)
-      : `${source.slice(start, start + MAX_DEFINITION_SOURCE_LENGTH - 3)}...`
+    const bounded = boundedDefinitionSource(source.slice(start, end))
     if (bounded.length === 0) return undefined
     const definition = Object.freeze({ source: bounded, line: span.line, column: span.column })
     extracted.set(key, definition)

package/internal/settings-compat.js

@@ -1,3 +1,55 @@
+/**
+ * Whether the installed settings generation owns the plugin's exported `Config`
+ * document.
+ *
+ * A generation that still attaches through the provider section installer — on
+ * its settings service, or on the package helper an older release published —
+ * validates the plugin's own fields and has no volatile contract. The
+ * generation that serves the exported `Config` itself, and commits only fields
+ * marked volatile, publishes neither installer. Both probes read the installed
+ * public surface, so no release identity selects the shape.
+ *
+ * @param settingsModule - the installed public settings package surface.
+ * @returns whether that generation serves the plugin's Config document itself.
+ */
+export function hostOwnsSettingsDocument(settingsModule) {
+  return typeof settingsModule?.installSettingsSection !== 'function'
+    && typeof settingsModule?.SettingsProvider?.prototype?.installSection !== 'function'
+}
+
+/**
+ * Build one exported `Config` field for the installed settings generation.
+ *
+ * A generation that serves the document itself keeps a form mounted and commits
+ * new values into the retained handle only for fields whose nearest schema
+ * ancestor is marked volatile, so the marker is applied there. A builder that
+ * does not publish that capability causes a dependency error during import; silently
+ * emitting ordinary fields would hide the form and every Client feature gated
+ * by its settings snapshot. The generation that installs its own section
+ * validates the same fields itself
+ * and must not receive the marker, because its validated defaults would become
+ * live handles its document path never commits.
+ *
+ * @param options.Schema - the schema builder the plugin imports.
+ * @param options.field - one field definition from `internal/config-spec.js`.
+ * @param options.settingsModule - the installed public settings package surface.
+ * @returns the Cordis schema field for that definition.
+ */
+export function configFieldSchema({ Schema, field, settingsModule }) {
+  const base = field.type === 'boolean'
+    ? Schema.boolean().default(field.default)
+    : field.type === 'enum'
+      // Keep omission visible until resolveConfig migrates legacy policies.
+      ? Schema.union(field.options.map(option => Schema.const(option)))
+      : Schema.number().step(1).min(field.min).max(field.max).default(field.default)
+  const described = base.description(field.description)
+  if (!hostOwnsSettingsDocument(settingsModule)) return described
+  if (typeof described.volatile !== 'function') {
+    throw new Error('ptc-plus: the host settings contract requires @deepseek-ai/schemastery with volatile(); reinstall the plugin to update its dependencies')
+  }
+  return described.volatile()
+}
+
 /** Install an optional settings section across current and legacy DSH settings APIs. */
 export function installSettingsSectionCompat({
   ctx,
@@ -6,6 +58,7 @@ export function installSettingsSectionCompat({
   schema,
   entry,
   hooks,
+  ownerFiber,
   onProvider,
 }) {
   ctx.inject(['settings'], settingsContext => {
@@ -16,7 +69,19 @@ export function installSettingsSectionCompat({
       return
     }
     if (typeof settingsModule?.installSettingsSection !== 'function') {
-      throw new Error('ptc-plus: incompatible settings service; expected installSection or installSettingsSection')
+      // The newest settings generation owns its document and card from the
+      // plugin's exported Config, so it exposes no section installer to call.
+      // Treat that shape as a host-owned surface instead of a load failure;
+      // the host commits volatile-only changes into the retained handles and
+      // notifies this fiber through `loader/volatile-update`.
+      if (typeof provider?.configure === 'function') {
+        // The host records the own-page policy against the profile entry's own
+        // fiber, so the owner is the plugin's entry context rather than the
+        // scope this installation happens to run in.
+        const dispose = provider.configure({ auto: false }, ownerFiber ?? ctx.fiber)
+        ctx.effect?.(() => dispose, 'ptc-plus settings page policy')
+      }
+      return
     }
     const mountedOwner = new Proxy(ctx, {
       get(target, property) {

package/internal/source-position-map.js

@@ -287,6 +287,25 @@ export function sourceLineStarts(source) {
   return starts
 }
 
+/** Convert one-based JavaScript source coordinates without admitting a
+ * position inside a line terminator. End coordinates may point immediately
+ * after the final content character. */
+export function sourceOffsetAtPosition(source, position, starts) {
+  if (typeof source !== 'string' || position === null || typeof position !== 'object'
+    || !Number.isSafeInteger(position.line) || position.line < 1
+    || !Number.isSafeInteger(position.column) || position.column < 1) return undefined
+  const lineStarts = starts ?? sourceLineStarts(source)
+  if (!Array.isArray(lineStarts) || position.line > lineStarts.length) return undefined
+  const lineStart = lineStarts[position.line - 1]
+  const nextLineStart = lineStarts[position.line]
+  let lineEnd = source.length
+  if (nextLineStart !== undefined) {
+    lineEnd = nextLineStart - (source[nextLineStart - 2] === '\r' && source[nextLineStart - 1] === '\n' ? 2 : 1)
+  }
+  const offset = lineStart + position.column - 1
+  return offset <= lineEnd ? offset : undefined
+}
+
 /** Visit maintained emitter coordinates without re-encoding available raw maps.
  * All line numbers at this boundary are zero-based; absent origins stay absent. */
 export function visitSourceMappings(transformed, visit) {

package/internal/user-binding-console-worker.js

@@ -16,6 +16,12 @@ import { USER_BINDING_TRANSFORM } from './module-transform-contract.js'
 import { moduleRuntimeIntrinsics } from './compiler-intrinsics.js'
 import { stringifyCompilerData } from './compiler-data.js'
 import { createCellCompletionObserver } from './cell-completion.js'
+import {
+  WORKER_REALM_MUTATION,
+  assignWorkerRealmProperty,
+  defineWorkerRealmProperty,
+  deleteWorkerRealmProperty,
+} from './worker-realm-surfaces.js'
 import { WORKER_SHUTDOWN_ACKNOWLEDGEMENT, WORKER_SHUTDOWN_REQUEST } from './worker-shutdown.js'
 import { WORKER_REPL_OPTIONS, createWorkerControlPromise, createWorkerReplErrorHandler,
   disableWorkerReplDomain,
@@ -31,10 +37,10 @@ const ControlPromise = createWorkerControlPromise()
 const evaluations = createPrivateAsyncLocalStorage()
 const context = globalThis
 const completionObserver = createCellCompletionObserver(runInWorkerReplRealm('Function'))
-context.console = console
+assignWorkerRealmProperty(WORKER_REALM_MUTATION.STABLE, 'console', context, 'console', console)
 let retainedEvaluator
 const completionKey = `__ptc_console_${randomUUID().replaceAll('-', '')}`
-Object.defineProperty(context, completionKey, { value: value => {
+defineWorkerRealmProperty(WORKER_REALM_MUTATION.TEMPORARY, undefined, context, completionKey, { value: value => {
   evaluations.getStore().completed = true
   return value
 } })
@@ -65,7 +71,8 @@ const moduleCompilation = createUserModuleCompilationHooks({
   transformForParent: parent => parent === replParent || parent === parentUrl ? USER_BINDING_TRANSFORM : undefined,
 })
 const providedRequire = managedRequire(parentUrl, createRequire(parentUrl))
-Object.defineProperty(context, 'require', { configurable: true, value: providedRequire })
+defineWorkerRealmProperty(WORKER_REALM_MUTATION.STABLE, 'cell module metadata',
+  context, 'require', { configurable: true, value: providedRequire })
 const importCanary = 'data:text/javascript,export default 1'
 registerHooks({ resolve(specifier, context, nextResolve) {
   if (specifier === importCanary) replParent = context.parentURL
@@ -86,10 +93,12 @@ process.on('uncaughtException', error => {
 function evaluate(source) {
   const prepared = prepareConsoleProgram(source, { languageSemantics: 'stateful-v1', knownBindings })
   const helpers = [prepared.rootRuntimeName, prepared.returnSignal]
-  Object.defineProperty(context, prepared.rootRuntimeName, {
+  defineWorkerRealmProperty(WORKER_REALM_MUTATION.TEMPORARY, undefined,
+    context, prepared.rootRuntimeName, {
     configurable: true, value: roots.begin({ ...prepared.rootBindings, committed: () => {} }),
   })
-  Object.defineProperty(context, prepared.returnSignal, { configurable: true, value: ConsoleReturn })
+  defineWorkerRealmProperty(WORKER_REALM_MUTATION.TEMPORARY, undefined,
+    context, prepared.returnSignal, { configurable: true, value: ConsoleReturn })
   if (prepared.moduleLoads.length === 0) {
     const operation = evaluatePrepared(prepared.code, prepared.asyncCompletion)
     return new ControlPromise((resolve, reject) => operation.then(
@@ -101,7 +110,9 @@ function evaluate(source) {
 }
 
 function removeHelpers(helpers) {
-  for (let index = 0; index < helpers.length; index++) delete context[helpers[index]]
+  for (let index = 0; index < helpers.length; index++) {
+    deleteWorkerRealmProperty(WORKER_REALM_MUTATION.RESTORE, undefined, context, helpers[index])
+  }
 }
 
 async function evaluateWithModules(prepared, helpers) {
@@ -132,7 +143,8 @@ async function evaluateWithModules(prepared, helpers) {
       } finally { setDelete(adapterParents, adapter) }
       if (load.global !== undefined) {
         appendArray(helpers, load.global)
-        Object.defineProperty(context, load.global, { configurable: true, value: namespace })
+        defineWorkerRealmProperty(WORKER_REALM_MUTATION.TEMPORARY, undefined,
+          context, load.global, { configurable: true, value: namespace })
       }
     }
     return await evaluatePrepared(prepared.code, prepared.asyncCompletion)
@@ -152,7 +164,8 @@ function evaluatePrepared(javascript, asyncCompletion = false) {
   protectWorkerReplAsyncContext(server)
   workerReplContext(server)
   restoreWorkerReplGlobals(workerGlobalBaseline, context)
-  Object.defineProperty(context, 'require', { configurable: true, value: providedRequire })
+  defineWorkerRealmProperty(WORKER_REALM_MUTATION.STABLE, 'cell module metadata',
+    context, 'require', { configurable: true, value: providedRequire })
   const errorDomain = disableWorkerReplDomain(server.eval.domain ?? createDomain())
   const evaluator = { server, input, output, errorDomain }
   retainedEvaluator = evaluator
@@ -205,7 +218,8 @@ try {
   for (let index = 0; index < names.length; index++) {
     const name = names[index]
     setAdd(knownBindings, name)
-    Object.defineProperty(context, name, { configurable: true, enumerable: true, get: () => namespace[name] })
+    defineWorkerRealmProperty(WORKER_REALM_MUTATION.USER, undefined,
+      context, name, { configurable: true, enumerable: true, get: () => namespace[name] })
   }
   parentPort.on('message', (message) => {
     if (message?.type === WORKER_SHUTDOWN_REQUEST) {

package/internal/user-binding-draft-projection.js

@@ -1,3 +1,4 @@
+import { isPtcMessageSource, PTC_MESSAGE_SOURCE_KIND } from './message-sources.js'
 import { isRecord } from './record-utils.js'
 import { normalizeBindingModelContext } from './user-binding-model-context.js'
 
@@ -51,13 +52,13 @@ function normalizeAction(value) {
 
 export function bindingActionNotice(action) {
   return {
-    source: { kind: 'plugin', plugin: 'ptc-plus', form: 'notice', summary: 'Global User Binding action' },
+    source: { kind: PTC_MESSAGE_SOURCE_KIND, form: 'notice', summary: 'Global User Binding action' },
     content: [{ type: 'text', text: ACTION_PREFIX + JSON.stringify(normalizeAction(action)) }],
   }
 }
 
 export function readBindingAction(message) {
-  if (message?.source?.kind !== 'plugin' || message.source.plugin !== 'ptc-plus'
+  if (!isPtcMessageSource(message?.source)
     || message.source.form !== 'notice' || message.source.summary !== 'Global User Binding action'
     || message.content?.length !== 1 || message.content[0]?.type !== 'text') return undefined
   try {

package/internal/user-bindings-owner.js

@@ -1,3 +1,4 @@
+import { PTC_MESSAGE_SOURCE_KIND } from './message-sources.js'
 import { RPC_CONTRACTS } from './rpc-contract.js'
 import { randomUUID } from 'node:crypto'
 import { dirname } from 'node:path'
@@ -87,7 +88,7 @@ function authoringTask(command, current) {
 function taskMessage(text) {
   return createUserMessage({
     content: [{ type: 'text', text }],
-    source: { kind: 'plugin', plugin: 'ptc-plus', form: 'instructions' },
+    source: { kind: PTC_MESSAGE_SOURCE_KIND, form: 'instructions' },
   })
 }
 

package/internal/user-bindings.js

@@ -1,6 +1,7 @@
 import { createHash } from 'node:crypto'
 import { identifier, exportedSymbols, sourceDurability } from './compiler-service.js'
 import { assertOwnFields, isRecord } from './record-utils.js'
+import { boundedDefinitionSource } from './repl-memory-projection.js'
 import { bindingModelPreferences, normalizeBindingModelContext } from './user-binding-model-context.js'
 import { supportedUserBindingTransform, USER_BINDING_TRANSFORM } from './module-transform-contract.js'
 
@@ -296,7 +297,11 @@ export function userBindingCatalogEntries(snapshot) {
     kind: binding.kind,
     entryId: entry.id,
     fingerprint: entry.fingerprint,
-    definition: Object.freeze({ source: binding.declaration, line: 1, column: 1 }),
+    definition: Object.freeze({
+      source: boundedDefinitionSource(binding.declaration),
+      line: 1,
+      column: 1,
+    }),
   })))
 }
 

package/internal/validated-parse-repair.js

@@ -1,6 +1,10 @@
 import { EXPECTED_TARGET_CALL_SEQ, editRejectedCell } from './rejected-cell-editor.js'
 
 const CLOSING_DELIMITERS = Object.freeze(['}', ')', ']'])
+const CLOSING_SUFFIXES = Object.freeze([
+  ...CLOSING_DELIMITERS,
+  ...CLOSING_DELIMITERS.flatMap(first => CLOSING_DELIMITERS.map(second => first + second)),
+])
 const LINE_TERMINATORS = /\r\n|[\n\r\u2028\u2029]/gu
 export const MAX_PARSE_REPAIR_ANCHOR_CODE_UNITS = 256
 
@@ -52,14 +56,14 @@ function renderInvocation(argumentsValue) {
   return `edit_run_code(${json})`
 }
 
-/** Returns a source-exact edit only when one bounded EOF-closing candidate is valid. */
+/** Requires exactly one valid suffix across all one- and two-token EOF closures. */
 export function validatedEofClosureRepair({ source, position, prepare, targetCallSeq }) {
   if (!Number.isSafeInteger(targetCallSeq) || targetCallSeq < 0
     || !isSourceEnd(source, position)) return undefined
   const anchor = boundedUniqueSuffix(source)
   if (anchor === undefined) return undefined
   const candidates = []
-  for (const delimiter of CLOSING_DELIMITERS) {
+  for (const delimiter of CLOSING_SUFFIXES) {
     const code = source + delimiter
     let prepared
     try {