@listen-fire/engine 0.12.0-rc.5 → 0.12.0-rc.7

package/dist/public/movement-engine.d.ts

@@ -6,6 +6,7 @@ export * from '../services/movement_engine/rust_stats';
 export * as programCheck from '../services/movement_engine/program_check';
 export { checkAnswerInRust, checkPinnedInRust, parsePinned, throwIfBlocking, type CheckAnswer, type CheckInput, type LinkData, type LinkedImportData, type Stamp, } from '../services/movement_engine/program_check';
 export { checkInputOf } from '../services/movement_engine/rust_run';
-/** This release of the engine. `lf` pins a new project to it and refuses a pin
- *  newer than it; lf's copy is held equal to this one by a cargo test. */
-export declare const ENGINE_VERSION = "0.12.0";
+/** This release of the engine, which is the language it reads
+ *  (`LANGUAGE_VERSION`): a run pinned to a release of another compatibility
+ *  key is refused by name. */
+export declare const ENGINE_VERSION: string;

package/dist/public/movement-engine.js

@@ -1,7 +1,7 @@
 "use strict";
 // The engine's front door: run a movement, resume a parked one, check a
-// program. The engine runs language version 5 and later on the Rust engine;
-// an earlier pin is refused by name.
+// program. The engine runs a pin that shares this release's compatibility
+// key; any other is refused by name, with the remedy.
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -30,6 +30,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ENGINE_VERSION = exports.checkInputOf = exports.throwIfBlocking = exports.parsePinned = exports.checkPinnedInRust = exports.checkAnswerInRust = exports.programCheck = exports.assertEngineConfigured = exports.runFailureCause = exports.RunCancelledSignal = exports.MovementRunFailed = exports.settleRaceFrame = exports.runMovement = exports.resumeMovement = exports.fireCallbackBody = void 0;
+const movement_lang_1 = require("@listen-fire/movement-lang");
 var rust_run_1 = require("../services/movement_engine/rust_run");
 Object.defineProperty(exports, "fireCallbackBody", { enumerable: true, get: function () { return rust_run_1.fireCallbackBody; } });
 Object.defineProperty(exports, "resumeMovement", { enumerable: true, get: function () { return rust_run_1.resumeMovement; } });
@@ -52,6 +53,7 @@ Object.defineProperty(exports, "parsePinned", { enumerable: true, get: function
 Object.defineProperty(exports, "throwIfBlocking", { enumerable: true, get: function () { return program_check_1.throwIfBlocking; } });
 var rust_run_2 = require("../services/movement_engine/rust_run");
 Object.defineProperty(exports, "checkInputOf", { enumerable: true, get: function () { return rust_run_2.checkInputOf; } });
-/** This release of the engine. `lf` pins a new project to it and refuses a pin
- *  newer than it; lf's copy is held equal to this one by a cargo test. */
-exports.ENGINE_VERSION = '0.12.0';
+/** This release of the engine, which is the language it reads
+ *  (`LANGUAGE_VERSION`): a run pinned to a release of another compatibility
+ *  key is refused by name. */
+exports.ENGINE_VERSION = movement_lang_1.LANGUAGE_VERSION;

package/dist/services/browser/contract.js

@@ -1,7 +1,7 @@
 "use strict";
 // The browser slot's contract suite: the cases every module filling the slot
 // is held to — the built-in `@lf/chromium` against a page served on loopback
-// (apps/api), and the scripted fake page the gated-document tests drive
+// (lf-platform's apps/api), and the scripted fake page the gated-document tests drive
 // (fake_browser.ts). Runner-agnostic, as the other slots' suites are: each
 // case is a name and an async body that throws on failure (node:assert).
 var __importDefault = (this && this.__importDefault) || function (mod) {

package/dist/services/movement_engine/binding.d.ts

@@ -262,7 +262,7 @@ export type BindingShape =
     kind: 'closure';
     closure: ClosureExpression;
     captured: Map<string, Binding>;
-    /** The name it was bound to (`f = (n) => …`, language version 3), by
+    /** The name it was bound to (`f = (n) => …`), by
      *  which its own body may call it: the capture is a snapshot taken
      *  before the name was bound, so the name is handed to each call
      *  instead (`invokeClosure`). */
@@ -437,7 +437,7 @@ export declare class Environment {
     /**
      * The declared name of a FUNCTION in scope (a movement, a plugin, an
      * import, a name bound to a closure) written `name` in another letter case
-     * — function names are case-insensitive from language version 3. The
+     * — function names are case-insensitive. The
      * checker refuses two functions whose names differ only by case, so at most
      * one answers.
      */

package/dist/services/movement_engine/binding.js

@@ -78,7 +78,7 @@ class Environment {
     /**
      * The declared name of a FUNCTION in scope (a movement, a plugin, an
      * import, a name bound to a closure) written `name` in another letter case
-     * — function names are case-insensitive from language version 3. The
+     * — function names are case-insensitive. The
      * checker refuses two functions whose names differ only by case, so at most
      * one answers.
      */

package/dist/services/movement_engine/call_depth.js

@@ -1,7 +1,7 @@
 "use strict";
-// The maximum CALL DEPTH of a movement run (language version 3).
+// The maximum CALL DEPTH of a movement run.
 //
-// From version 3 a function may call itself, directly or through others. A
+// A function may call itself, directly or through others. A
 // recursion that never reaches its base case would otherwise run until the
 // process ran out of stack — or, where every level makes a priced call, until
 // the cost cap stopped it, having spent the cap. The depth limit stops it

package/dist/services/movement_engine/program_check.js

@@ -42,12 +42,12 @@ const errors_1 = require("./errors");
 const RETIRED_BUT_STILL_RUNNABLE = new Set(['MOV_WRITE_SHAPE_RETIRED']);
 /** The pin, the parse: MOVENG_LANGUAGE_VERSION or MOVENG_PARSE. */
 function parsePinned(input) {
-    const languageVersion = input.languageVersion ?? movement_lang_1.CURRENT_LANGUAGE_VERSION;
+    const languageVersion = input.languageVersion ?? movement_lang_1.LANGUAGE_VERSION;
     // The pin is answered before the source is read: a version this release
     // cannot honour must fail as exactly that, not as whatever the current
     // grammar makes of the text.
     const versionDiagnostic = (0, movement_lang_1.languageVersionDiagnostic)(languageVersion);
-    if (versionDiagnostic !== undefined && (versionDiagnostic.severity ?? 'error') === 'error') {
+    if (versionDiagnostic !== undefined) {
         throw new errors_1.MovementEngineError('MOVENG_LANGUAGE_VERSION', versionDiagnostic.message, [
             versionDiagnostic,
         ]);
@@ -67,7 +67,7 @@ function parsePinned(input) {
  *  stamps and link the run reads; this one answers only whether the run may
  *  open a segment at all. */
 function checkPinnedInRust(input) {
-    const languageVersion = input.languageVersion ?? movement_lang_1.CURRENT_LANGUAGE_VERSION;
+    const languageVersion = input.languageVersion ?? movement_lang_1.LANGUAGE_VERSION;
     parsePinned(input);
     const diagnostics = (0, movement_lang_1.checkSourceInRust)(input.source, input.catalog, {
         languageVersion,
@@ -79,7 +79,7 @@ function checkPinnedInRust(input) {
 /** `checkPinnedInRust`, answered as data (the `check.program` host call):
  *  every diagnostic, the import link and the checker's stamps. */
 function checkAnswerInRust(input) {
-    const languageVersion = input.languageVersion ?? movement_lang_1.CURRENT_LANGUAGE_VERSION;
+    const languageVersion = input.languageVersion ?? movement_lang_1.LANGUAGE_VERSION;
     parsePinned(input);
     const answer = (0, movement_lang_1.checkAnswerInRust)(input.source, input.catalog, {
         languageVersion,

package/dist/services/movement_engine/rust_engine.d.ts

@@ -38,7 +38,7 @@ export interface EngineProtocol {
     finish(): void;
 }
 /** For a process's boot: a retired engine setting fails startup. Ignoring
- *  it would silently drop what an operator asked for (a version-5 run on the
+ *  it would silently drop what an operator asked for (a current run on the
  *  TypeScript engine, say). */
 export declare function assertEngineConfigured(env?: Record<string, string | undefined>): void;
 export { PARKED_ON_TYPESCRIPT } from './errors';
@@ -108,13 +108,10 @@ export declare function driveEngine(engine: EngineProtocol, start: unknown, { wa
     /** Absent: no wall clock (a test's double). */
     wallClockSeconds?: number;
 }): Promise<unknown>;
-/** What a segment ended in: its result, a refusal at its entry (nothing ran
- *  but its parse), or a decline after its check (nothing the host can see
- *  happened). */
+/** What a segment ended in: its result, or a decline after its check
+ *  (nothing the host can see happened). */
 type RunOutcome = {
     ran: MovementRunResult;
-} | {
-    refused: string;
 } | {
     declined: string;
 };
@@ -122,7 +119,7 @@ type RunOutcome = {
  * The segment's `done` (crates/movement-engine/src/run.rs says its shapes):
  * the run's result, the error it failed with (a body's failure wrapped in
  * `MovementRunFailed`, carrying what the run did, as the interpreter wraps
- * it), or that it refused or declined.
+ * it), or that it declined.
  */
 export declare function readRunResult(done: unknown, run: {
     context: Pick<RunContext, 'trace' | 'ledger'>;

package/dist/services/movement_engine/rust_engine.js

@@ -8,10 +8,10 @@
 // it, in the shapes docs/contracts/host-families.md freezes, and the shim forwards each one
 // to the run's `EngineHost` (rust_host.ts).
 //
-// This engine runs language version 5 and later (rust_run.ts refuses an
+// This engine runs the current language (rust_run.ts refuses an
 // earlier pin at the entry). There is no fallback: whatever the Rust engine
 // refuses or declines fails the run (MOVENG_UNSUPPORTED). The checker is the one gate that keeps a
-// saved program from reaching such a refusal, and a test holds every version-5
+// saved program from reaching such a refusal, and a test holds every current
 // program in the repository to that (rust_reachability.unit.test.ts). Each
 // segment is logged once (`noteEngine`) and counted (`rustRunStats`).
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -44,13 +44,13 @@ Object.defineProperty(exports, "plainJson", { enumerable: true, get: function ()
  *  emergency switch. Each named a choice that no longer exists. */
 const RETIRED_ENGINE_SETTINGS = ['MOVEMENT_ENGINE', 'MOVEMENT_ENGINE_FALLBACK', 'MOVEMENT_ENGINE_DRY_RUN_EVERY', 'MOVEMENT_ENGINE_V5_ON_TS'];
 /** For a process's boot: a retired engine setting fails startup. Ignoring
- *  it would silently drop what an operator asked for (a version-5 run on the
+ *  it would silently drop what an operator asked for (a current run on the
  *  TypeScript engine, say). */
 function assertEngineConfigured(env = process.env) {
     const set = RETIRED_ENGINE_SETTINGS.filter((name) => env[name] !== undefined && env[name] !== '');
     if (set.length === 0)
         return;
-    throw new Error(`${set.join(', ')} ${set.length === 1 ? 'is' : 'are'} retired: a run's engine follows its pinned language version (5 and later the Rust engine, 1–4 the TypeScript engine), with no fallback between them. Remove ${set.length === 1 ? 'it' : 'them'} from the environment.`);
+    throw new Error(`${set.join(', ')} ${set.length === 1 ? 'is' : 'are'} retired: a run's engine follows its pinned language version (this release's language on the Rust engine, the platform's earlier integer-pinned languages on its TypeScript engine), with no fallback between them. Remove ${set.length === 1 ? 'it' : 'them'} from the environment.`);
 }
 var errors_2 = require("./errors");
 Object.defineProperty(exports, "PARKED_ON_TYPESCRIPT", { enumerable: true, get: function () { return errors_2.PARKED_ON_TYPESCRIPT; } });
@@ -137,15 +137,13 @@ async function segmentInRust({ input, context, checkedBefore = false }, resume,
         throw error;
     }
     rust_stats_1.rustRunStats.segments += 1;
-    if ('refused' in outcome)
-        throw unsupportedInRust(input, outcome.refused);
     if ('declined' in outcome)
         throw unsupportedInRust(input, outcome.declined);
     noteEngine(input, RAN);
     return outcome.ran;
 }
 /** A segment the Rust engine (or this shim, on its behalf) would not run:
- *  counted by reason, and the run fails. No other engine runs a version-5
+ *  counted by reason, and the run fails. No other engine runs a current
  *  program, so this is never a slow path: a checked program that reaches it
  *  is a checker or engine bug. */
 function unsupportedInRust(input, reason) {
@@ -420,14 +418,11 @@ function segmentInput(input, context, { resume }, wire) {
         // The engine checks the program itself (the Rust checker): a run on
         // this engine is held to it, and the host is never asked.
         // It checks against the snapshot's own `models`, as the host's checker
-        // does, not the run's list sent on the catalog below. A deprecated
-        // pin's warning is the release's, which is this host's, as the host's
-        // check answer's is (rust_host.ts `check.program`).
+        // does, not the run's list sent on the catalog below.
         nativeCheck: true,
         snapshotModels: input.catalog.models ?? null,
-        ...versionWarningOf(context.languageVersion),
-        // The pin the run is under, written out: the engine cannot know this
-        // release's current version.
+        // The pin the run is under, written out (absent on the input, this
+        // release's): the engine holds it to the rule again at its entry.
         languageVersion: context.languageVersion,
         ...(input.movementName !== undefined ? { movementName: input.movementName } : {}),
         event,
@@ -457,7 +452,7 @@ function segmentInput(input, context, { resume }, wire) {
         // deployment's, read here so the engine reads no environment; the
         // number as written, a fraction included, which the marker prints.
         extractionFileChars: (0, segment_limits_1.maxFileChars)(),
-        // How many named calls deep the run may nest (version 3): the
+        // How many named calls deep the run may nest: the
         // deployment's, read here for the same reason.
         maxCallDepth: (0, call_depth_1.maxCallDepth)(),
         // What one segment may consume (docs/contracts/run-limits.md): the
@@ -469,21 +464,14 @@ function segmentInput(input, context, { resume }, wire) {
         extractionTiers: (0, ai_tiers_1.extractionTierAssignments)(),
     }, 'the segment input');
 }
-/** The pin's standing warning as this release words it (`languageVersionDiagnostic`). */
-function versionWarningOf(languageVersion) {
-    const warning = (0, movement_lang_1.languageVersionDiagnostic)(languageVersion);
-    return warning !== undefined ? { versionWarning: { code: warning.code, message: warning.message } } : {};
-}
 /**
  * The segment's `done` (crates/movement-engine/src/run.rs says its shapes):
  * the run's result, the error it failed with (a body's failure wrapped in
  * `MovementRunFailed`, carrying what the run did, as the interpreter wraps
- * it), or that it refused or declined.
+ * it), or that it declined.
  */
 function readRunResult(done, run) {
     const outcome = (0, rust_wire_1.record)(done, 'the Rust engine result');
-    if ('refused' in outcome)
-        return { refused: (0, rust_wire_1.string)(outcome.refused, 'the Rust engine refused') };
     if ('declined' in outcome)
         return { declined: (0, rust_wire_1.string)(outcome.declined, 'the Rust engine declined') };
     // What the segment's priced calls spent was charged to the run's account

package/dist/services/movement_engine/rust_host.d.ts

@@ -1,4 +1,4 @@
-import { type CatalogSnapshot, type Program } from '@listen-fire/movement-lang';
+import { type LanguageVersion, type CatalogSnapshot, type Program } from '@listen-fire/movement-lang';
 import { type EngineHost } from './host';
 import { type RunContext } from './segment_context';
 import type { HostAnswer, HostRequest } from './rust_engine';
@@ -31,8 +31,8 @@ export declare function shimRoutePaths(): string[];
 /** The segment a forwarded request names (`serve` has held it to the one
  *  the run host opened). */
 /** A program's key in `RouteContext.checked`: its source under its pin. */
-export declare function checkedKey(source: string, languageVersion: number): string;
+export declare function checkedKey(source: string, languageVersion: LanguageVersion): string;
 /** The program `check.compatible` asks about, checked once per segment
  *  against the segment's own catalog (`RouteContext.checked`). */
-export declare function checkedProgram(context: Pick<RouteContext, 'catalog' | 'checked'>, source: string, languageVersion: number): Program;
+export declare function checkedProgram(context: Pick<RouteContext, 'catalog' | 'checked'>, source: string, languageVersion: LanguageVersion): Program;
 export declare function serve(request: HostRequest, context: RouteContext): Promise<HostAnswer>;

package/dist/services/movement_engine/rust_host.js

@@ -53,38 +53,17 @@ exports.ENGINE_OWN_ROUTES = {
 const ROUTES = {
     /** The Rust checker over the pinned source (program_check.ts
      *  `checkAnswerInRust`): every diagnostic, the import link and the
-     *  checker's AST stamps as data, and the run's version warning for a
-     *  deprecated pin. A program that fails its check ends the run with the
-     *  check's error, as the run's own check throws it. */
+     *  checker's AST stamps as data. The request names no pin: the run's own
+     *  was held to the rule at its entry. A program that fails its check ends
+     *  the run with the check's error, as the run's own check throws it. */
     async 'check.program'(request, context) {
-        const languageVersion = request.languageVersion;
-        if (typeof languageVersion !== 'number')
-            throw new rust_wire_1.RustShimError('check.program languageVersion must be a number');
-        const upgradingFrom = request.upgradingFrom;
-        if (upgradingFrom !== undefined && typeof upgradingFrom !== 'number') {
-            throw new rust_wire_1.RustShimError('check.program upgradingFrom must be a number');
-        }
         const source = (0, rust_wire_1.string)(request.source, 'check.program source');
-        let answer;
         try {
-            answer = (0, program_check_1.checkAnswerInRust)({
-                source,
-                catalog: context.catalog,
-                languageVersion,
-                ...(upgradingFrom !== undefined ? { upgradingFrom } : {}),
-            });
+            return (0, program_check_1.checkAnswerInRust)({ source, catalog: context.catalog, languageVersion: context.context.languageVersion });
         }
         catch (error) {
             throw new rust_wire_1.RunAborted(error);
         }
-        // The run's own version warning, read as the TypeScript engine reads it
-        // (run.ts, before the body): the release the engine runs under, not the
-        // checker's own view of it, which a host may hold apart.
-        const versionWarning = (0, movement_lang_1.languageVersionDiagnostic)(languageVersion);
-        return {
-            ...answer,
-            ...(versionWarning !== undefined ? { versionWarning: { code: versionWarning.code, message: versionWarning.message } } : {}),
-        };
     },
     /** `x IS <Decl>` of a record a system describes (the event, a handle, a
      *  landed record): does the schema's `recordType` carry everything the
@@ -96,9 +75,7 @@ const ROUTES = {
      *  there as `surfaceMisfit` compares a landing across an edge. With
      *  `file`, the declaration is a library's, checked as its own file. */
     async 'check.compatible'(request, context) {
-        const languageVersion = request.languageVersion;
-        if (typeof languageVersion !== 'number')
-            throw new rust_wire_1.RustShimError('check.compatible languageVersion must be a number');
+        const languageVersion = context.context.languageVersion;
         // The declaration's own file: a library's, by its path in the snapshot.
         const file = (0, rust_wire_1.optionalString)(request.file, 'check.compatible file');
         const source = file === undefined ? (0, rust_wire_1.string)(request.source, 'check.compatible source') : context.catalog.files?.[file]?.source;
@@ -112,7 +89,7 @@ const ROUTES = {
             throw new rust_wire_1.RustShimError('check.compatible schema is an instance schema');
         const path = (0, rust_wire_1.optionalStringList)(request.path, 'check.compatible path');
         try {
-            return (0, movement_lang_1.compatibleInRust)({ source, languageVersion, declaration, schema, recordType, ...(path !== undefined ? { path } : {}) });
+            return (0, movement_lang_1.compatibleInRust)({ source, declaration, schema, recordType, ...(path !== undefined ? { path } : {}) });
         }
         catch (error) {
             if (error instanceof movement_lang_1.RustCheckRefused)
@@ -198,9 +175,7 @@ const ROUTES = {
         const constraints = wire.read(request.constraints);
         if (!isUniquenessConstraints(constraints))
             throw new rust_wire_1.RustShimError('llm.arbitrateEntities constraints are {any: [{all}]}');
-        const languageVersion = request.languageVersion;
-        if (typeof languageVersion !== 'number')
-            throw new rust_wire_1.RustShimError('llm.arbitrateEntities languageVersion is a number');
+        const languageVersion = (0, rust_wire_1.string)(request.languageVersion, 'llm.arbitrateEntities languageVersion');
         const answer = await host.llm.arbitrateEntities({
             asserted,
             candidates,
@@ -298,7 +273,7 @@ const ROUTES = {
         // The files the plugin's output declares, made here (as the TypeScript
         // engine's priced invoker makes them): the engine is handed handles.
         const spec = (0, segment_context_1.pluginSpecNamed)(catalog.plugins, (0, rust_wire_1.string)(request.plugin, 'llm.transforms.invoke plugin'));
-        const output = spec !== undefined ? (0, segment_context_1.pluginOutputUnder)(spec, context.languageVersion) : undefined;
+        const output = spec?.output;
         const typed = 'error' in answer ? answer : (0, segment_context_1.withDeclaredFiles)(answer, output);
         return new Plain(wired(wire, typed, 'llm.transforms.invoke'));
     },

package/dist/services/movement_engine/rust_run.js

@@ -1,11 +1,10 @@
 "use strict";
 // The engine's run entry: run a movement, resume a parked one, settle a race
 // frame, fire a callback's body. Each opens one segment (`inRunContext`) and
-// runs it on the Rust engine (rust_engine.ts). The engine runs language
-// version 5 and later; a run pinned earlier is refused at the entry, by name,
-// in the words a release uses for a version it does not support. Saved
-// movements pinned below 5 run where they were saved, on a platform that
-// keeps an engine for them.
+// runs it on the Rust engine (rust_engine.ts). The engine runs a pin that
+// shares this release's compatibility key; any other is refused at the
+// entry, by name, with the remedy. Saved movements of an older language run
+// where they were saved, on a platform that keeps an engine for them.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runMovement = runMovement;
 exports.resumeMovement = resumeMovement;
@@ -19,14 +18,6 @@ const host_adapter_1 = require("./host_adapter");
 const program_check_1 = require("./program_check");
 const rust_engine_1 = require("./rust_engine");
 const segment_context_1 = require("./segment_context");
-/** The first language version this engine runs. */
-const FIRST_ENGINE_LANGUAGE_VERSION = 5;
-/** This release as the engine answers for it: the versions it supports, from
- *  the first one the engine runs. */
-const ENGINE_RELEASE = {
-    ...movement_lang_1.THIS_RELEASE,
-    supported: new Set([...movement_lang_1.THIS_RELEASE.supported].filter((version) => version >= FIRST_ENGINE_LANGUAGE_VERSION)),
-};
 async function runMovement(given) {
     const input = (0, host_adapter_1.withIsoEvent)(given);
     refuseEarlierPin(input);
@@ -73,19 +64,17 @@ async function fireCallbackBody(given) {
     return (0, segment_context_1.inRunContext)(input, (context) => (0, rust_engine_1.fireSegmentInRust)({ input, context, checkedBefore: true }));
 }
 /**
- * A run pinned below the first version this engine runs is refused, in the
- * words a release uses for a version it does not support. A run pinned to a
- * version the engine runs that the TypeScript engine parked (under the
- * retired MOVEMENT_ENGINE_V5_ON_TS switch) has no engine to resume on.
+ * A run pinned to a language this release does not read is refused, by the
+ * pin's standing. A run the TypeScript engine parked (under the retired
+ * MOVEMENT_ENGINE_V5_ON_TS switch) has no engine to resume on.
  */
 function refuseEarlierPin(input) {
-    const languageVersion = input.languageVersion ?? movement_lang_1.CURRENT_LANGUAGE_VERSION;
-    if (languageVersion < FIRST_ENGINE_LANGUAGE_VERSION) {
-        const refusal = (0, movement_lang_1.languageVersionDiagnostic)(languageVersion, ENGINE_RELEASE);
-        throw new errors_1.MovementEngineError('MOVENG_LANGUAGE_VERSION', refusal?.message ?? `this engine runs language version ${FIRST_ENGINE_LANGUAGE_VERSION} and later`);
-    }
+    const languageVersion = input.languageVersion ?? movement_lang_1.LANGUAGE_VERSION;
+    const refusal = (0, movement_lang_1.languageVersionDiagnostic)(languageVersion);
+    if (refusal !== undefined)
+        throw new errors_1.MovementEngineError('MOVENG_LANGUAGE_VERSION', refusal.message);
     if (input.parkedOnEngine === 'ts') {
-        throw new errors_1.MovementEngineError('MOVENG_UNSUPPORTED', `this run is pinned to language version ${languageVersion}, which runs only on the Rust engine, but the TypeScript engine parked it: it cannot resume`, { reason: errors_1.PARKED_ON_TYPESCRIPT });
+        throw new errors_1.MovementEngineError('MOVENG_UNSUPPORTED', `this run is pinned to language ${languageVersion}, which runs only on the Rust engine, but the TypeScript engine parked it: it cannot resume`, { reason: errors_1.PARKED_ON_TYPESCRIPT });
     }
 }
 /** What the check reads of a run's input. */

package/dist/services/movement_engine/rust_stats.d.ts

@@ -25,7 +25,7 @@ export declare const rustRunStats: {
 };
 export declare function resetRustRunStats(): void;
 /** The engine that ran one segment of a run. A resume reads it back
- *  (`parkedOnEngine`) to refuse a version-5 park the TypeScript engine
+ *  (`parkedOnEngine`) to refuse a current park the TypeScript engine
  *  wrote. */
 export interface RunEngineRecord {
     runId: string;

package/dist/services/movement_engine/segment_context.d.ts

@@ -6,10 +6,6 @@ import type { AwaitWakeRequest, AdapterResolution, CallbackSink, EngineHost, Rec
 import { RunCostCapExceeded, type Budget, type CostLine, type RunSpend } from '../../lib/run_cost';
 /** The plugins a run's catalog snapshot describes, by name. */
 export type PluginSpecs = Readonly<Record<string, PluginSpec>>;
-/** What a plain call to `spec`'s plugin hands back to a program pinned to
- *  `languageVersion`: its current output, or an older shape it kept for
- *  programs pinned before the change (`PluginSpec.earlierOutputs`). */
-export declare function pluginOutputUnder(spec: PluginSpec, languageVersion: LanguageVersion): PluginOutput | undefined;
 /** A plugin by either spelling: movement identifiers can't carry dashes, so a
  *  program writes `vc_url_retrieval` for a plugin registered as
  *  `vc-url-retrieval`; the snapshot keys the underscore spelling. */

package/dist/services/movement_engine/segment_context.js

@@ -27,7 +27,6 @@
 // read by the run host, never by the engine.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RunLedger = void 0;
-exports.pluginOutputUnder = pluginOutputUnder;
 exports.pluginSpecNamed = pluginSpecNamed;
 exports.hostless = hostless;
 exports.stopwatch = stopwatch;
@@ -47,13 +46,6 @@ const types_1 = require("../../lib/utils/types");
 const logger_1 = require("../logger");
 const errors_1 = require("./errors");
 const run_cost_1 = require("../../lib/run_cost");
-/** What a plain call to `spec`'s plugin hands back to a program pinned to
- *  `languageVersion`: its current output, or an older shape it kept for
- *  programs pinned before the change (`PluginSpec.earlierOutputs`). */
-function pluginOutputUnder(spec, languageVersion) {
-    const earlier = spec.earlierOutputs?.find((entry) => languageVersion < entry.before);
-    return earlier !== undefined ? earlier.output : spec.output;
-}
 /** A plugin by either spelling: movement identifiers can't carry dashes, so a
  *  program writes `vc_url_retrieval` for a plugin registered as
  *  `vc-url-retrieval`; the snapshot keys the underscore spelling. */
@@ -83,7 +75,7 @@ async function stopwatch(clock) {
 /** The pin a callee honours: its run's, or — outside a run (a script, a test
  *  calling the extraction directly) — the current version. */
 function languageVersionOf(run) {
-    return run?.languageVersion ?? movement_lang_1.CURRENT_LANGUAGE_VERSION;
+    return run?.languageVersion ?? movement_lang_1.LANGUAGE_VERSION;
 }
 /**
  * The cancel check every boundary INSIDE a statement makes (runs-and-cancel
@@ -399,7 +391,7 @@ async function inRunContext(input, run) {
         host: input.host,
         teamId: input.teamId,
         ...(input.runId !== undefined ? { runId: input.runId } : {}),
-        languageVersion: input.languageVersion ?? movement_lang_1.CURRENT_LANGUAGE_VERSION,
+        languageVersion: input.languageVersion ?? movement_lang_1.LANGUAGE_VERSION,
         ...(input.firedAt !== undefined ? { firedAt: input.firedAt } : {}),
         spend: {
             priorMicrodollars: input.priorSpentMicrodollars ?? 0,

package/dist/services/movement_engine/test_host.d.ts

@@ -95,7 +95,7 @@ export declare function makeMemoryParkSources(): {
     texts: Map<string, string>;
 };
 /**
- * What the Rust run's counts (`rustRunStats`) say of how one version-5 run
+ * What the Rust run's counts (`rustRunStats`) say of how one current run
  * that threw `error` (none for a run that returned) ended: at its check
  * (`isCheckFailure`) with no segment opened; or in one segment, run to its
  * end (its own failure included), with no engine refusal and no shim fault.

package/dist/services/movement_engine/test_host.js

@@ -168,7 +168,7 @@ function makeMemoryParkSources() {
 }
 // ── How a Rust run ended ──────────────────────────────────────────────────────
 /**
- * What the Rust run's counts (`rustRunStats`) say of how one version-5 run
+ * What the Rust run's counts (`rustRunStats`) say of how one current run
  * that threw `error` (none for a run that returned) ended: at its check
  * (`isCheckFailure`) with no segment opened; or in one segment, run to its
  * end (its own failure included), with no engine refusal and no shim fault.

package/dist/services/plugins/registry.js

@@ -98,19 +98,6 @@ const VC_URL_RETRIEVAL_SIGNATURE = {
             },
         },
         description: 'Every link it fetched, one record each. Empty when there was no link worth following.',
-        // Language version 1: every page it fetched as one text.
-        previously: [
-            {
-                before: 2,
-                output: {
-                    kind: 'value',
-                    type: { kind: 'string' },
-                    optional: true,
-                    description: 'The text of every page it fetched, run together. Nothing when there was no link '
-                        + 'worth following.',
-                },
-            },
-        ],
     },
 };
 /**
@@ -207,9 +194,9 @@ const LINKEDIN_ENRICHMENT_SIGNATURE = {
             linkedin_profile: { kind: 'string' },
         },
     },
-    // What a call hands back from language version 5, where the record a stage
+    // What a call hands back where the record a stage
     // fed it is the call's argument. Before 5 nothing can call it — it is fed
-    // only by an extraction — so this is read by version 5 alone.
+    // only by an extraction — so this is read by the current language alone.
     output: {
         kind: 'record',
         fields: {

package/dist/services/run_host/contract.js

@@ -1,7 +1,7 @@
 "use strict";
 // The run host's contract suite: one set of cases, written against the backend
 // families (store.ts) and the core's rules over them, run against every
-// backend (the hosted Postgres one in apps/api's integration set, `lf`'s
+// backend (the hosted Postgres one in lf-platform's apps/api integration set, `lf`'s
 // SQLite one in apps/cli's tests). Ported from the hosted integration tests
 // (work store, join_pending, park sink, run lease, await correlation, the
 // resume drivers) and lf's state tests, keeping the cases about what the

package/dist/services/translation_graph/movement/file_listeners.d.ts

@@ -1,4 +1,4 @@
-import type { Program } from '@listen-fire/movement-lang';
+import type { LanguageVersion, Program } from '@listen-fire/movement-lang';
 /** One `listen` statement, with its instance's construction resolved. */
 export interface FileListener {
     instanceName: string;
@@ -23,5 +23,5 @@ export interface FileListener {
  * anything still unresolvable here is skipped defensively.
  */
 export declare function collectFileListeners(program: Program, options?: {
-    languageVersion?: number;
+    languageVersion?: LanguageVersion;
 }): FileListener[];

package/dist/services/translation_graph/movement/file_listeners.js

@@ -54,7 +54,7 @@ function collectFileListeners(program, options = {}) {
     };
     // A run host unit (`listen to manual fire …`) the file does not bind itself
     // is the host's own, credential-free and argument-free.
-    const units = (0, movement_lang_1.runHostUnits)(options.languageVersion ?? movement_lang_1.CURRENT_LANGUAGE_VERSION);
+    const units = movement_lang_1.RUN_HOST_UNITS;
     const unitConstruction = (name) => (units.includes(name) && !imported.has(name) ? { adapter: name } : undefined);
     const original = (local) => importOriginals.get(local) ?? local;
     for (const statement of program.statements) {

package/dist/services/translation_graph/movement/schema_projection.js

@@ -508,8 +508,8 @@ function instanceSchemaFromDescriptors(input) {
             // A system's own edge and its reserved resources reference may share a
             // name (a team's ontology edge called `Resources`): the system's own
             // edge is the one the name walks, whichever the describe listed first.
-            // The reserved reference stays reachable by its address (versions
-            // 1–4's `_resources`).
+            // The reserved reference stays reachable by its address (the older
+            // language's `_resources`).
             const existing = edges[edge];
             if (existing === undefined ||
                 (existing.resources === true && ref.fieldId !== adapter_1.RESOURCES_REFERENCE_FIELD_ID)) {
@@ -565,7 +565,7 @@ function instanceSchemaFromDescriptors(input) {
                     // The system's resources edge (the reserved `_resources` reference,
                     // walked by its own name — the knowledge graph's `Resources`). The
                     // read wrapper sends a walk of it by its reserved fieldId (its
-                    // address, not its name), and since language version 5 the checker's
+                    // address, not its name), and the checker's
                     // refusal of `x-[f:_resources]->` off a record names it.
                     ...(ref.fieldId === adapter_1.RESOURCES_REFERENCE_FIELD_ID ? { resources: true } : {}),
                     ...(edgeDescription !== undefined ? { description: edgeDescription } : {}),
@@ -607,7 +607,7 @@ function instanceSchemaFromDescriptors(input) {
                 ...(writeOnlyProperties.length > 0 ? { writeOnlyProperties } : {}),
                 ...(ambiguousProperties.length > 0 ? { ambiguousProperties } : {}),
                 // The system removes a record of this type (its `deleteRecord`) — the
-                // promise `delete x` is checked against since language version 5.
+                // promise `delete x` is checked against.
                 ...(descriptor.deletable === true ? { deletable: true } : {}),
                 // The adapter's own words for the type and its fields, which the
                 // language service's hover leads with.

package/dist/services/translation_graph/segment_scope.js

@@ -226,7 +226,7 @@ function inSegment(segmentId, fn) {
 async function withSegment(input, fn) {
     const { segmentId } = await openSegment({
         teamId: (0, engine_contracts_1.tenantIdOf)(input.teamId),
-        languageVersion: input.languageVersion ?? movement_lang_1.CURRENT_LANGUAGE_VERSION,
+        languageVersion: input.languageVersion ?? movement_lang_1.LANGUAGE_VERSION,
         ...(input.runId !== undefined ? { runId: input.runId } : {}),
     });
     try {
@@ -268,7 +268,7 @@ exports.segmentScopedCalls = {
  * describe, tests) there is no pin and this is the current version.
  */
 function currentLanguageVersion() {
-    return asyncLocalStorage.getStore()?.languageVersion ?? movement_lang_1.CURRENT_LANGUAGE_VERSION;
+    return asyncLocalStorage.getStore()?.languageVersion ?? movement_lang_1.LANGUAGE_VERSION;
 }
 /**
  * Serve `key` from what this segment has already read, or read it and

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@listen-fire/engine",
   "license": "Apache-2.0",
-  "version": "0.12.0-rc.5",
-  "description": "The movement engine for language version 5 and later and its host contract: the Rust engine's shim, the EngineHost families, the run host, the embed kit, and the adapter and model types they reach. Every shell (the hosted product, the `lf` command line, an embedder) runs the same engine. A run pinned below version 5 is refused by name. Embedders reach it only through public/* (the exports map); the internals resolve only under the `movement-engine-internals` condition, which only test runners set",
+  "version": "0.12.0-rc.7",
+  "description": "The movement engine for this release's language and its host contract: the Rust engine's shim, the EngineHost families, the run host, the embed kit, and the adapter and model types they reach. Every shell (the hosted product, the `lf` command line, an embedder) runs the same engine. A run pinned to a release this one does not read is refused by name. Embedders reach it only through public/* (the exports map); the internals resolve only under the `movement-engine-internals` condition, which only test runners set",
   "engines": {
     "node": "22.20.0"
   },
@@ -17,9 +17,9 @@
   "dependencies": {
     "safe-stable-stringify": "2.5.0",
     "zod": "4.1.12",
-    "@listen-fire/module-runtime": "^0.12.0-rc.5",
-    "@listen-fire/movement-lang": "^0.12.0-rc.5",
-    "@listen-fire/engine-contracts": "^0.12.0-rc.5"
+    "@listen-fire/movement-lang": "^0.12.0-rc.7",
+    "@listen-fire/engine-contracts": "^0.12.0-rc.7",
+    "@listen-fire/module-runtime": "^0.12.0-rc.7"
   },
   "devDependencies": {
     "@types/jest": "29.5.14",