@namzu/sdk 58.1.1 → 60.0.0

package/src/compaction/context-window.ts

@@ -30,6 +30,111 @@
  * only ever as fresh as the day someone checked it.
  */
 
+/** The window an id declares with the `[1m]` suffix, and the ceiling `NAMZU_AUTO_COMPACT_WINDOW` accepts. */
+export const ONE_MILLION_WINDOW_TOKENS = 1_000_000
+/** The window a model is held to when `NAMZU_DISABLE_1M_CONTEXT` is on. */
+export const DISABLED_ONE_MILLION_WINDOW_CAP_TOKENS = 200_000
+
+const WINDOW_SUFFIX = /\[1m\]$/i
+
+/**
+ * A model id may end in `[1m]` (any case) to declare a one-million-token
+ * window, whether or not the id is recognised. The suffix is a marker for
+ * Namzu, never part of the vendor's name: strip it with this before an id
+ * reaches a driver or a wire.
+ */
+export function splitModelWindowSuffix(model: string): {
+	readonly model: string
+	readonly declaresOneMillion: boolean
+} {
+	const match = WINDOW_SUFFIX.exec(model)
+	if (!match) return { model, declaresOneMillion: false }
+	return { model: model.slice(0, match.index), declaresOneMillion: true }
+}
+
+/** The id with any `[1m]` suffix removed. */
+export function stripModelWindowSuffix(model: string): string {
+	return splitModelWindowSuffix(model).model
+}
+
+/**
+ * `NAMZU_DISABLE_1M_CONTEXT` (1, true, yes or on): the suffix is still
+ * stripped but declares nothing, and no window above 200,000 tokens is
+ * assumed for a model whose window comes from a driver or the table.
+ */
+export function oneMillionWindowDisabled(env: NodeJS.ProcessEnv = process.env): boolean {
+	const value = env.NAMZU_DISABLE_1M_CONTEXT?.trim().toLowerCase()
+	return value === '1' || value === 'true' || value === 'yes' || value === 'on'
+}
+
+/** Smallest and largest window `NAMZU_AUTO_COMPACT_WINDOW` can name. */
+export const AUTO_COMPACT_WINDOW_MIN_TOKENS = 100_000
+export const AUTO_COMPACT_WINDOW_MAX_TOKENS = ONE_MILLION_WINDOW_TOKENS
+
+export type AutoCompactWindowParse =
+	| { readonly kind: 'in_range'; readonly tokens: number }
+	| { readonly kind: 'below_minimum'; readonly tokens: number }
+	| { readonly kind: 'above_maximum' }
+	| { readonly kind: 'unusable' }
+
+/**
+ * Read an automatic-summary window the way people write one: a plain number
+ * (`200000`) or one with a `k` or `m` suffix (`786k`, `1m`, `1.5m`). Anything
+ * under 100,000 is `below_minimum`, over 1,000,000 `above_maximum`, and
+ * something that is not a size at all `unusable`.
+ */
+export function parseAutoCompactWindow(raw: string): AutoCompactWindowParse {
+	const text = raw.trim()
+	const last = text.slice(-1).toLowerCase()
+	const scale = last === 'm' ? 1_000_000 : last === 'k' ? 1_000 : undefined
+	const digits = scale === undefined ? text : text.slice(0, -1)
+	const valid = scale === undefined ? /^\+?\d+$/ : /^\+?\d+(\.\d+)?$/
+	const value = valid.test(digits) ? Number(digits) * (scale ?? 1) : Number.NaN
+	if (Number.isNaN(value) || value < 1) return { kind: 'unusable' }
+	if (value < AUTO_COMPACT_WINDOW_MIN_TOKENS)
+		return {
+			kind: 'below_minimum',
+			tokens: Math.min(AUTO_COMPACT_WINDOW_MIN_TOKENS - 1, Math.round(value)),
+		}
+	if (value > AUTO_COMPACT_WINDOW_MAX_TOKENS) return { kind: 'above_maximum' }
+	return { kind: 'in_range', tokens: Math.round(value) }
+}
+
+/**
+ * The window to use for a written size, and a one-line warning when what was
+ * written had to be changed: below 100,000 reads as 100,000, above 1,000,000
+ * as 1,000,000, and a non-size is ignored (`tokens` undefined). `source`
+ * names where it was written, e.g. `NAMZU_AUTO_COMPACT_WINDOW`.
+ */
+export function resolveAutoCompactWindowSetting(
+	raw: string | number,
+	source: string,
+): { readonly tokens: number | undefined; readonly warning?: string } {
+	const text = String(raw)
+	const parsed = parseAutoCompactWindow(text)
+	const shown = `${source}="${text.slice(0, 32).replace(/[^\w.,+ $%{}=;-]+/g, '?')}${text.length > 32 ? '\u2026' : ''}"`
+	const advice = 'Set it to a size from 100k to 1M, such as 200k or 200000, or unset it.'
+	switch (parsed.kind) {
+		case 'in_range':
+			return { tokens: parsed.tokens }
+		case 'below_minimum':
+			return {
+				tokens: AUTO_COMPACT_WINDOW_MIN_TOKENS,
+				warning: `${shown} reads as ${parsed.tokens.toLocaleString('en-US')} tokens, so Namzu treats it as the 100k minimum. ${advice}`,
+			}
+		case 'above_maximum':
+			return {
+				tokens: AUTO_COMPACT_WINDOW_MAX_TOKENS,
+				warning: `${shown} is too large, so Namzu treats it as the 1M maximum. ${advice}`,
+			}
+		case 'unusable':
+			return {
+				tokens: undefined,
+				warning: `${shown} isn't a usable size, so Namzu ignores it. ${advice}`,
+			}
+	}
+}
+
 /**
  * Conservative default for a model we do not recognise.
  *
@@ -85,9 +190,32 @@ const WINDOWS: ReadonlyArray<readonly [prefix: string, tokens: number]> = [
 	['qwen', 32_768],
 	['mistral-large', 128_000],
 	['mixtral', 32_768],
+	// The current DeepSeek models document a 1M window
+	// (https://api-docs.deepseek.com/quick_start/pricing), listed per id: a
+	// gateway can serve a derivative under a name that merely starts like one
+	// (a fine-tune, a distill), and nothing says it keeps the parent's window.
+	// Over-estimating ends a turn on a provider rejection; under-estimating
+	// costs a summary. So an id not named here falls to the bare `deepseek`
+	// row below, the 64k the older ids (chat, reasoner, R1 distills) had. The
+	// three ids are matched whole (see `DEEPSEEK_ONE_MILLION_IDS`), never by
+	// substring.
 	['deepseek', 64_000],
 ]
 
+/** DeepSeek ids documented at a 1M window; matched exactly, not by substring. */
+const DEEPSEEK_ONE_MILLION_IDS: ReadonlySet<string> = new Set([
+	'deepseek-v4-flash',
+	'deepseek-v4-pro',
+	'deepseek-flash',
+])
+
+/** The id with a gateway prefix (`deepseek/`) and a `:tag` (`:free`) removed. */
+function bareModelName(id: string): string {
+	const afterSlash = id.slice(id.lastIndexOf('/') + 1)
+	const colon = afterSlash.indexOf(':')
+	return colon === -1 ? afterSlash : afterSlash.slice(0, colon)
+}
+
 const SORTED = [...WINDOWS].sort((a, b) => b[0].length - a[0].length)
 
 /**
@@ -98,7 +226,19 @@ const SORTED = [...WINDOWS].sort((a, b) => b[0].length - a[0].length)
  */
 export function lookupContextWindow(model: string | undefined): number | undefined {
 	if (!model) return undefined
-	const id = model.toLowerCase()
+	const { declaresOneMillion } = splitModelWindowSuffix(model)
+	const known = lookupBareContextWindow(model)
+	if (declaresOneMillion && !oneMillionWindowDisabled()) {
+		return Math.max(known ?? 0, ONE_MILLION_WINDOW_TOKENS)
+	}
+	return known
+}
+
+/** The table's answer for an id with any `[1m]` suffix ignored. */
+function lookupBareContextWindow(model: string | undefined): number | undefined {
+	if (!model) return undefined
+	const id = stripModelWindowSuffix(model).toLowerCase()
+	if (DEEPSEEK_ONE_MILLION_IDS.has(bareModelName(id))) return ONE_MILLION_WINDOW_TOKENS
 	for (const [prefix, tokens] of SORTED) {
 		if (id.includes(prefix)) return tokens
 	}
@@ -191,13 +331,34 @@ export function resolveContextWindow(
 	if (configured !== undefined && configured > 0) {
 		return { tokens: configured, source: 'config' }
 	}
+	const { declaresOneMillion } = splitModelWindowSuffix(model ?? '')
+	const disabled = oneMillionWindowDisabled()
+	const base = resolveUndeclaredWindow(model, providerReported)
+	// `[1m]` raises the window to at least a million (reported as 'model-table':
+	// the id itself is the fact), never lowers one a
+	// driver or the table already puts higher.
+	if (declaresOneMillion && !disabled && base.tokens < ONE_MILLION_WINDOW_TOKENS) {
+		return { tokens: ONE_MILLION_WINDOW_TOKENS, source: 'model-table' }
+	}
+	// With the million-token window switched off, nothing assumed or reported
+	// for a model counts for more than 200,000.
+	if (disabled && base.tokens > DISABLED_ONE_MILLION_WINDOW_CAP_TOKENS) {
+		return { tokens: DISABLED_ONE_MILLION_WINDOW_CAP_TOKENS, source: base.source }
+	}
+	return base
+}
+
+function resolveUndeclaredWindow(
+	model: string | undefined,
+	providerReported: number | undefined,
+): ResolvedContextWindow {
 	if (providerReported !== undefined && providerReported > 0) {
 		return { tokens: providerReported, source: 'provider' }
 	}
 	// A driver that resolved `undefined` falls through to HERE, not to the
 	// default. "I asked and it does not know" leaves the table exactly as
 	// authoritative as it was before anyone asked.
-	const known = lookupContextWindow(model)
+	const known = lookupBareContextWindow(model)
 	if (known !== undefined) {
 		return { tokens: known, source: 'model-table' }
 	}

package/src/execution/workflow/index.ts

@@ -1,8 +1,21 @@
 export { WorkflowScriptError } from './errors.js'
 export { FileWorkflowJournal } from './journal.js'
 export { parseWorkflowMeta } from './meta.js'
+export {
+	formatWorkflowJournalLine,
+	loadWorkflowResume,
+	readWorkflowJournalChecked,
+	workflowCallKey,
+	workflowJournalLineHash,
+	workflowJournalSeed,
+} from './resume.js'
+export type { WorkflowCallIdentity } from './resume.js'
 export { summarizeWorkflowPhases } from './phases.js'
 export type { PhaseAgentView, PhaseRecord } from './phases.js'
-export { resolveWorkflowLimits, WORKFLOW_HOST_CALL, WorkflowRuntime } from './runtime.js'
+export {
+	resolveWorkflowLimits,
+	WORKFLOW_HOST_CALL,
+	WorkflowRuntime,
+} from './runtime.js'
 export type { WorkflowRuntimeOptions } from './runtime.js'
 export type * from './types.js'

package/src/execution/workflow/journal.ts

@@ -1,8 +1,19 @@
 import { createHash } from 'node:crypto'
-import { appendFile, mkdir, writeFile } from 'node:fs/promises'
-import { join } from 'node:path'
+import { mkdir, open, readFile, stat, writeFile } from 'node:fs/promises'
+import { basename, dirname, join, resolve } from 'node:path'
 
-import type { WorkflowJournal, WorkflowJournalRecord } from './types.js'
+import {
+	formatWorkflowJournalLine,
+	readWorkflowJournalChecked,
+	workflowJournalLineHash,
+	workflowJournalSeed,
+} from './resume.js'
+import type {
+	CheckedWorkflowJournal,
+	WorkflowJournal,
+	WorkflowJournalReader,
+	WorkflowJournalRecord,
+} from './types.js'
 
 export function sha256(text: string): string {
 	return createHash('sha256').update(text).digest('hex')
@@ -17,30 +28,169 @@ export function preview(text: string, max = 500): string {
 	return `${text.slice(0, end)}…`
 }
 
+/** The chain state of one journal file, shared by every writer in this process. */
+interface ChainState {
+	queue: Promise<void>
+	loaded: boolean
+	seq: number
+	prev: string
+	needsNewline: boolean
+	finished: boolean
+	/** Bytes the file had after the last write this process made; a different size means someone else wrote. */
+	size: number
+	/** Appends queued or running; the state is dropped once a pass's end is written and none are left. */
+	pending: number
+}
+
+const chains = new Map<string, ChainState>()
+
+/** Records after which a crash must not lose the line: a saved result, the end of a pass, the start of one. */
+function mustSurviveCrash(record: WorkflowJournalRecord): boolean {
+	return (
+		record.type === 'run_finished' ||
+		record.type === 'run_started' ||
+		(record.type === 'agent_outcome' && Object.hasOwn(record, 'result'))
+	)
+}
+
 /**
  * A journal in a directory: `script.js` (the exact script text, mode 0600)
  * and `journal.jsonl` (one JSON record per line, append-only). The caller
  * chooses the directory, normally `<session>/runs/<runId>/workflow/`.
+ *
+ * Every line carries `seq` and `prev` (the hash of the line before it, the
+ * first chaining from a seed bound to the run id), so a line that was edited,
+ * removed or cut short is found when the journal is read back. One writer per
+ * file serves the whole process: a resumed pass and a late agent of the pass
+ * before it append through the same queue and the same chain, and nothing is
+ * appended after a pass's `run_finished` until the next pass starts. This
+ * assumes one process writes the file at a time, which the session lease
+ * already guarantees. A chain proves the file was not damaged or edited by
+ * accident; someone who can rewrite the whole file can rewrite the chain too.
  */
-export class FileWorkflowJournal implements WorkflowJournal {
+export class FileWorkflowJournal implements WorkflowJournal, WorkflowJournalReader {
 	private ready: Promise<void> | undefined
+	private readonly file: string
 
-	constructor(private readonly dir: string) {}
+	constructor(
+		private readonly dir: string,
+		private readonly options: {
+			readonly runId?: string
+			/** A secret that signs every line; see `readWorkflowJournalChecked`. */
+			readonly key?: string | Uint8Array
+		} = {},
+	) {
+		this.file = resolve(dir, 'journal.jsonl')
+	}
 
 	private ensure(): Promise<void> {
 		this.ready ??= mkdir(this.dir, { recursive: true, mode: 0o700 }).then(() => undefined)
 		return this.ready
 	}
 
-	async writeScript(source: string): Promise<void> {
-		await this.ensure()
-		await writeFile(join(this.dir, 'script.js'), source, { mode: 0o600 })
+	/** The run id of the file's first line, learned from the file or from the first `run_started` written. */
+	private learned: string | undefined
+
+	private runId(record?: WorkflowJournalRecord, text?: string): string {
+		if (this.options.runId !== undefined) return this.options.runId
+		if (record?.type === 'run_started') this.learned = record.runId
+		if (this.learned !== undefined) return this.learned
+		const first = text?.slice(0, text.indexOf('\n') < 0 ? undefined : text.indexOf('\n'))
+		if (first) {
+			try {
+				const parsed = JSON.parse(first) as { type?: unknown; runId?: unknown }
+				if (parsed.type === 'run_started' && typeof parsed.runId === 'string') {
+					this.learned = parsed.runId
+					return parsed.runId
+				}
+			} catch {
+				// Not a record: fall back to the folder name below.
+			}
+		}
+		return basename(dirname(resolve(this.dir)))
 	}
 
-	async append(record: WorkflowJournalRecord): Promise<void> {
+	async writeScript(source: string, _sha256?: string, pass = 1): Promise<void> {
 		await this.ensure()
-		await appendFile(join(this.dir, 'journal.jsonl'), `${JSON.stringify(record)}\n`, {
-			mode: 0o600,
+		const name = pass <= 1 ? 'script.js' : `script.${pass}.js`
+		await writeFile(join(this.dir, name), source, { mode: 0o600 })
+	}
+
+	async read(): Promise<CheckedWorkflowJournal> {
+		let text: string
+		try {
+			text = await readFile(this.file, 'utf8')
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error
+			text = ''
+		}
+		return readWorkflowJournalChecked(text, this.runId(undefined, text), {
+			...(this.options.key !== undefined ? { key: this.options.key } : {}),
+		})
+	}
+
+	append(record: WorkflowJournalRecord): Promise<void> {
+		let state = chains.get(this.file)
+		if (state === undefined) {
+			state = {
+				queue: Promise.resolve(),
+				loaded: false,
+				seq: 0,
+				prev: '',
+				needsNewline: false,
+				finished: false,
+				size: 0,
+				pending: 0,
+			}
+			chains.set(this.file, state)
+		}
+		const chain = state
+		chain.pending++
+		const run = chain.queue.then(async () => {
+			await this.ensure()
+			const onDisk = await stat(this.file).then(
+				(info) => info.size,
+				() => 0,
+			)
+			if (!chain.loaded || onDisk !== chain.size) {
+				const checked = await this.read()
+				chain.seq = checked.lastSeq
+				chain.prev = checked.lastHash
+				chain.needsNewline = !checked.endsWithNewline
+				chain.finished = checked.records.at(-1)?.type === 'run_finished'
+				chain.loaded = true
+				chain.size = onDisk
+			}
+			if (record.type === 'run_started') chain.finished = false
+			// Nothing belongs after the pass's end; a late agent of that pass is dropped here.
+			else if (chain.finished) return
+			if (chain.seq === 0) chain.prev = workflowJournalSeed(this.runId(record))
+			const seq = chain.seq + 1
+			const line = formatWorkflowJournalLine(record, seq, chain.prev, this.options.key)
+			const handle = await open(this.file, 'a', 0o600)
+			try {
+				const text = `${chain.needsNewline ? '\n' : ''}${line}\n`
+				await handle.appendFile(text)
+				chain.size += Buffer.byteLength(text)
+				if (mustSurviveCrash(record)) await handle.datasync()
+			} finally {
+				await handle.close()
+			}
+			chain.needsNewline = false
+			chain.seq = seq
+			chain.prev = workflowJournalLineHash(line)
+			if (record.type === 'run_finished') chain.finished = true
 		})
+		chain.queue = run
+			.catch(() => undefined)
+			.then(() => {
+				chain.pending--
+				// A finished run keeps no state: the next append reads the file again, and
+				// what it finds (a last `run_finished`) is the same thing the state held.
+				if (chain.pending === 0 && chain.finished && chains.get(this.file) === chain) {
+					chains.delete(this.file)
+				}
+			})
+		return run
 	}
 }

package/src/execution/workflow/prelude.ts

@@ -28,7 +28,7 @@ const PRELUDE_SOURCE = String.raw`(function (config) {
 	}
 	function phase(title) {
 		var t = clean(title, 120);
-		if (!t) throw new TypeError('phase() needs a non-empty title.');
+		if (!t) throw misuse('phase() needs a non-empty title.');
 		cursor = t;
 		emit({ k: 'phase', title: t });
 	}
@@ -53,13 +53,26 @@ const PRELUDE_SOURCE = String.raw`(function (config) {
 		return e;
 	}
 	function isBudgetError(e) { return !!e && e.name === 'WorkflowBudgetExceededError'; }
+	function misuse(message) {
+		var e = new TypeError(message);
+		e.workflowMisuse = true;
+		return e;
+	}
+	function isMisuse(e) { return !!e && e.workflowMisuse === true; }
+	var optionNames = ['label', 'phase', 'schema', 'agentType', 'model', 'effort'];
 	async function agent(prompt, opts) {
 		if (typeof prompt !== 'string' || prompt.length === 0) {
-			throw new TypeError('agent(prompt, options?): the prompt must be a non-empty string, got ' + kind(prompt));
+			throw misuse('agent(prompt, options?): the prompt must be a non-empty string, got ' + kind(prompt));
 		}
 		var o = opts == null ? {} : opts;
 		if (typeof o !== 'object' || Array.isArray(o)) {
-			throw new TypeError('agent(prompt, options?): options must be an object, got ' + kind(o));
+			throw misuse('agent(prompt, options?): options must be an object, got ' + kind(o));
+		}
+		var unknown = Object.keys(o).filter(function (k) { return optionNames.indexOf(k) < 0; });
+		if (unknown.length > 0) {
+			// Ignored, as it always was, but no longer silently: a saved script that
+			// misspells an option keeps running and the line says why it had no effect.
+			log('agent(prompt, options?): ignoring unknown option "' + unknown[0] + '"; the options are ' + optionNames.join(', ') + '.');
 		}
 		if (overBudget()) throw budgetError();
 		var request = { prompt: prompt, cursor: cursor };
@@ -69,23 +82,32 @@ const PRELUDE_SOURCE = String.raw`(function (config) {
 		if (o.agentType != null) request.agentType = clean(o.agentType, 120);
 		if (o.model != null) request.model = clean(o.model, 120);
 		if (o.effort != null) request.effort = clean(o.effort, 32);
-		var reply = await rawCall('agent', request);
+		var reply;
+		try {
+			reply = await rawCall('agent', request);
+		} catch (e) {
+			// The host rejects a malformed request with an "agent(): ..." message;
+			// that is the script's mistake, not a failed child.
+			if (e && typeof e.message === 'string' && e.message.indexOf('agent(): ') === 0) throw misuse(e.message);
+			throw e;
+		}
 		spent.tokensUsed = reply.t;
 		return reply.v;
 	}
 	async function parallel(thunks) {
 		if (!Array.isArray(thunks)) {
-			throw new TypeError('parallel(thunks): the argument must be an array of functions, got ' + kind(thunks));
+			throw misuse('parallel(thunks): the argument must be an array of functions, got ' + kind(thunks));
 		}
 		for (var p = 0; p < thunks.length; p++) {
 			if (typeof thunks[p] !== 'function') {
-				throw new TypeError('parallel(thunks): item ' + (p + 1) + ' must be a function (wrap the work as () => agent(...)), got ' + kind(thunks[p]));
+				throw misuse('parallel(thunks): item ' + (p + 1) + ' must be a function (wrap the work as () => agent(...)), got ' + kind(thunks[p]));
 			}
 		}
 		var dropped = 0;
 		var results = await Promise.all(thunks.map(function (t, n) {
 			return Promise.resolve().then(t).catch(function (e) {
 				if (isBudgetError(e)) { dropped++; return null; }
+				if (isMisuse(e)) throw e;
 				log('Step ' + (n + 1) + ' stopped: ' + clean(e && e.message ? e.message : e, 300));
 				return null;
 			});
@@ -95,12 +117,12 @@ const PRELUDE_SOURCE = String.raw`(function (config) {
 	}
 	async function pipeline(items) {
 		if (!Array.isArray(items)) {
-			throw new TypeError('pipeline(items, ...stages): the first argument must be an array, got ' + kind(items));
+			throw misuse('pipeline(items, ...stages): the first argument must be an array, got ' + kind(items));
 		}
 		var stages = Array.prototype.slice.call(arguments, 1);
 		for (var s = 0; s < stages.length; s++) {
 			if (typeof stages[s] !== 'function') {
-				throw new TypeError('pipeline(items, ...stages): stage ' + (s + 1) + ' must be a function, got ' + kind(stages[s]));
+				throw misuse('pipeline(items, ...stages): stage ' + (s + 1) + ' must be a function, got ' + kind(stages[s]));
 			}
 		}
 		if (items.length > 0 && overBudget()) throw budgetError();
@@ -112,6 +134,7 @@ const PRELUDE_SOURCE = String.raw`(function (config) {
 					value = await stages[i](value, item, index);
 				} catch (e) {
 					if (isBudgetError(e)) { dropped++; return null; }
+					if (isMisuse(e)) throw e;
 					log('Item ' + (index + 1) + ' stopped at step ' + (i + 1) + ': ' + clean(e && e.message ? e.message : e, 300));
 					return null;
 				}
@@ -141,6 +164,24 @@ const PRELUDE_SOURCE = String.raw`(function (config) {
 	install('log', log);
 	install('budget', budget);
 	install('args', config.args);
+	if (config.deterministic) {
+		var RealDate = Date;
+		var clockMessage = 'Date.now() / new Date() are unavailable in workflow scripts (breaks resume). Stamp results after the workflow returns, or pass timestamps through args.';
+		var randomMessage = 'Math.random() is unavailable in workflow scripts (breaks resume). For N independent samples, include the index in the agent label or prompt.';
+		var ShimDate = function Date(a, b, c, d, e, f, g) {
+			if (!new.target || arguments.length === 0) throw new Error(clockMessage);
+			return Reflect.construct(RealDate, Array.prototype.slice.call(arguments), new.target === ShimDate ? RealDate : new.target);
+		};
+		Object.defineProperty(ShimDate, 'prototype', { value: RealDate.prototype, writable: false, configurable: false });
+		Object.defineProperty(ShimDate, 'now', { value: function now() { throw new Error(clockMessage); }, writable: false, configurable: false });
+		Object.defineProperty(ShimDate, 'parse', { value: RealDate.parse, writable: false, configurable: false });
+		Object.defineProperty(ShimDate, 'UTC', { value: RealDate.UTC, writable: false, configurable: false });
+		Object.defineProperty(RealDate.prototype, 'constructor', { value: ShimDate, writable: false, configurable: false });
+		Object.defineProperty(globalThis, 'Date', { value: ShimDate, writable: false, configurable: false, enumerable: false });
+		Object.defineProperty(Math, 'random', { value: function random() { throw new Error(randomMessage); }, writable: false, configurable: false });
+		try { delete globalThis.eval; } catch (ignored) {}
+		Object.freeze(RealDate);
+	}
 })`
 
 /**
@@ -151,6 +192,7 @@ const PRELUDE_SOURCE = String.raw`(function (config) {
 export function preludeLineCount(config: {
 	args: unknown
 	tokenLimit: number | null
+	deterministic?: boolean
 }): number {
 	return buildPrelude(config).split('\n').length
 }
@@ -159,6 +201,7 @@ export function preludeLineCount(config: {
 export function buildPrelude(config: {
 	args: unknown
 	tokenLimit: number | null
+	deterministic?: boolean
 }): string {
 	const literal = JSON.stringify(config)
 		.split(String.fromCharCode(0x2028))