@listen-fire/movement-lang 0.12.0-rc.6 → 0.12.0-rc.7

package/dist/catalog/types.d.ts

@@ -1,4 +1,3 @@
-import type { LanguageVersion } from '../language_version';
 import type { EdgeCapability, EdgeSequencing, Expression, FieldCapability } from '../expression/types';
 /**
  * One argument in an adapter's construction signature. The list is the full
@@ -277,16 +276,6 @@ export interface PluginSpec {
      * goes to the extractor, not to a name.
      */
     output?: PluginOutput;
-    /**
-     * The shapes `output` had before it changed: each is what a plain call hands
-     * back to a program pinned before language version `before`, earliest
-     * first. A call is typed under its program's pin (`pluginOutputUnder`);
-     * removing a language version removes its entries.
-     */
-    earlierOutputs?: ReadonlyArray<{
-        before: LanguageVersion;
-        output: PluginOutput;
-    }>;
     /** The package tag it is a member of (`@lf/web`), matched exactly
      *  (`packageMembers`); absent when it is in none. */
     package?: string;
@@ -313,7 +302,7 @@ export declare function pluginKey(packageTag: string, name: string): string;
 export declare function pluginProgramNameOf(key: string, spec: PluginSpec): string;
 /** What a written plugin name stands for among `plugins`: the entry keyed by
  *  exactly that (a package member's key), else the one entry whose name it is
- *  (a bare import, as versions 1 to 4 write it); several such are `ambiguous`,
+ *  (a bare import, as the older language writes it); several such are `ambiguous`,
  *  listing the packages that serve it. The Rust twin is `find_plugin`. */
 export declare function findPlugin(plugins: Readonly<Record<string, PluginSpec>>, name: string): {
     found: {
@@ -519,7 +508,7 @@ export interface EdgeSchema {
      * The edge is the one the system declared as its records' resources (the
      * describe's reserved `_resources` reference — the knowledge graph's
      * `Resources`). An ordinary edge, walked by its name like any other; what
-     * the flag records is that a pre-version-5 `x-[f:_resources]->` on this
+     * the flag records is that an older `x-[f:_resources]->` on this
      * system read it, so MOV_RESOURCES_NOT_EXTRACTED can name it. Diagnostics
      * only: nothing resolves `_resources` to it.
      */
@@ -662,8 +651,7 @@ export interface PositionSchema {
     /**
      * A record of this type can be DELETED — the system's own promise, declared
      * per type in its describe (`deletable: true`) where its `deleteRecord`
-     * removes one. Absent ⇒ it makes no such promise, and since language
-     * version 5 `delete x` of this type is MOV_DELETE_NOT_DECLARED (an
+     * removes one. Absent ⇒ it makes no such promise, and `delete x` of this type is MOV_DELETE_NOT_DECLARED (an
      * undescribed or pending position says nothing, so nothing is refused).
      */
     deletable?: boolean;

package/dist/catalog/types.js

@@ -76,15 +76,15 @@ function unquoteConstructionArg(raw) {
     }
     return trimmed;
 }
-// ── A plugin's arguments by position (language version 5, design §2.7) ──
+// ── A plugin's arguments by position (design §2.7) ──
 //
 // Its required inputs in the manifest's declared order, then one optional
 // settings record `{ name: value }` for the rest. Binding turns that call into
-// the named arguments versions 1–4 write, so every check and the wire to the
+// the named arguments the older language writes, so every check and the wire to the
 // plugin read one form. The Rust twin is `PluginSpec::bind_args`
 // (crates/movement-parser/src/catalog/plugin_args.rs); both checkers and both
 // engines bind through these two and nothing else.
-// ── A plugin package (language version 5, design §2.10, §4.3) ──
+// ── A plugin package (design §2.10, §4.3) ──
 //
 // A tag a plugin's spec declares as its `package`, matched exactly and never
 // parsed. ``import { `@lf/web` as web } from plugins`` binds each member under
@@ -102,7 +102,7 @@ function pluginProgramNameOf(key, spec) {
 }
 /** What a written plugin name stands for among `plugins`: the entry keyed by
  *  exactly that (a package member's key), else the one entry whose name it is
- *  (a bare import, as versions 1 to 4 write it); several such are `ambiguous`,
+ *  (a bare import, as the older language writes it); several such are `ambiguous`,
  *  listing the packages that serve it. The Rust twin is `find_plugin`. */
 function findPlugin(plugins, name) {
     const exact = Object.hasOwn(plugins, name) ? plugins[name] : undefined;
@@ -148,7 +148,7 @@ function refinementKey(input) {
 }
 /**
  * The filter with its field reads' `fieldOnly` marks dropped. The mark says
- * how a read was SPELLED — through the hop's alias from version 5
+ * how a read was SPELLED — through the hop's alias
  * (`e.action`), bare before (`action`) — and both spellings name the same
  * field, so the key must not tell them apart: a host registers its narrowing
  * once, from its own filter, and every version's program must find it.

package/dist/checker/rust_checker.d.ts

@@ -1,9 +1,11 @@
-import type { LanguageVersion } from '../language_version';
+import { type LanguageVersion, type LanguageVersionStanding } from '../language_version';
 import type { CatalogSnapshot } from '../service/snapshot';
 import type { Diagnostic } from './diagnostic';
 export interface RustCheckOptions {
+    /** The movement's pin, held to the rule before the artifact is asked: the
+     *  artifact checks in its own release's language. */
     languageVersion: LanguageVersion;
-    /** Checking for a move up from this version (`CheckOptions.upgradingFrom`). */
+    /** Checking for a move up from this release (`CheckOptions.upgradingFrom`). */
     upgradingFrom?: LanguageVersion;
 }
 /** A source the Rust checker could not check: it does not parse, or the
@@ -11,8 +13,18 @@ export interface RustCheckOptions {
 export declare class RustCheckRefused extends Error {
     constructor(message: string);
 }
+/** The language the artifact reads: its release's version. */
+export declare function languageVersion(): LanguageVersion;
+/** How `pin` stands against the artifact's release, and the refusal's text
+ *  when it does not read it (the rule in Rust: the drift test holds it equal
+ *  to `languageVersionStanding`). */
+export declare function languageStanding(pin: string): {
+    standing: LanguageVersionStanding;
+    message: string | null;
+};
 /** Every diagnostic the Rust checker reports for `source` against
- *  `snapshot`, warnings and info included. */
+ *  `snapshot`, warnings and info included. A pin this release does not read
+ *  is its standing diagnostic alone, the artifact not asked. */
 export declare function checkSourceInRust(source: string, snapshot: CatalogSnapshot, options: RustCheckOptions): Diagnostic[];
 /** A checker fact about one node, keyed by its AST path (a JSON Pointer from
  *  the Program, `file` naming a library's): a write spread's field list, a
@@ -66,7 +78,6 @@ export declare function checkAnswerInRust(source: string, snapshot: CatalogSnaps
  *  when the schema enumerates nothing at the record type. */
 export declare function compatibleInRust(request: {
     source: string;
-    languageVersion: LanguageVersion;
     declaration: string;
     schema: unknown;
     recordType: string;

package/dist/checker/rust_checker.js

@@ -10,10 +10,13 @@
 // editor's live diagnostics stay on the TypeScript checker.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RustCheckRefused = void 0;
+exports.languageVersion = languageVersion;
+exports.languageStanding = languageStanding;
 exports.checkSourceInRust = checkSourceInRust;
 exports.checkAnswerInRust = checkAnswerInRust;
 exports.compatibleInRust = compatibleInRust;
 const loader_1 = require("../wasm/loader");
+const language_version_1 = require("../language_version");
 /** A source the Rust checker could not check: it does not parse, or the
  *  snapshot does not load. */
 class RustCheckRefused extends Error {
@@ -23,10 +26,35 @@ class RustCheckRefused extends Error {
     }
 }
 exports.RustCheckRefused = RustCheckRefused;
+/** The language the artifact reads: its release's version. */
+function languageVersion() {
+    const reply = (0, loader_1.callLanguageVersion)();
+    if (!reply.ok || typeof reply.json !== 'string')
+        throw new Error(`language_version: ${JSON.stringify(reply.json)}`);
+    return reply.json;
+}
+/** How `pin` stands against the artifact's release, and the refusal's text
+ *  when it does not read it (the rule in Rust: the drift test holds it equal
+ *  to `languageVersionStanding`). */
+function languageStanding(pin) {
+    const reply = (0, loader_1.callLanguageStanding)(pin);
+    const json = reply.json;
+    if (!reply.ok || !isRecord(json) || !isStanding(json.standing) || (json.message !== null && typeof json.message !== 'string')) {
+        throw new Error(`language_standing: ${JSON.stringify(json)}`);
+    }
+    return { standing: json.standing, message: json.message };
+}
+function isStanding(value) {
+    return value === 'compatible' || value === 'newer' || value === 'olderKey' || value === 'malformed';
+}
 /** Every diagnostic the Rust checker reports for `source` against
- *  `snapshot`, warnings and info included. */
+ *  `snapshot`, warnings and info included. A pin this release does not read
+ *  is its standing diagnostic alone, the artifact not asked. */
 function checkSourceInRust(source, snapshot, options) {
-    const reply = (0, loader_1.callCheckProgram)(source, JSON.stringify(snapshot), options.languageVersion, options.upgradingFrom ?? 0);
+    const refusal = (0, language_version_1.languageVersionDiagnostic)(options.languageVersion);
+    if (refusal !== undefined)
+        return [refusal];
+    const reply = (0, loader_1.callCheckProgram)(source, JSON.stringify(snapshot), callOptions(options));
     const json = reply.json;
     if (!reply.ok)
         throw refused(json);
@@ -37,7 +65,10 @@ function checkSourceInRust(source, snapshot, options) {
 }
 /** `checkSourceInRust` as data (crates/movement-checker/src/answer.rs). */
 function checkAnswerInRust(source, snapshot, options) {
-    const reply = (0, loader_1.callCheckAnswer)(source, JSON.stringify(snapshot), options.languageVersion, options.upgradingFrom ?? 0);
+    const refusal = (0, language_version_1.languageVersionDiagnostic)(options.languageVersion);
+    if (refusal !== undefined)
+        return { diagnostics: [refusal], stamps: [] };
+    const reply = (0, loader_1.callCheckAnswer)(source, JSON.stringify(snapshot), callOptions(options));
     const json = reply.json;
     if (!reply.ok)
         throw refused(json);
@@ -65,6 +96,9 @@ function compatibleInRust(request) {
         return { fits: json.fits };
     throw new Error(`the Rust checker answered check.compatible with ${JSON.stringify(json)}`);
 }
+function callOptions(options) {
+    return options.upgradingFrom === undefined ? {} : { upgradingFrom: options.upgradingFrom };
+}
 function refused(json) {
     const error = isRecord(json) && isRecord(json.error) ? json.error : undefined;
     return new RustCheckRefused(typeof error?.message === 'string' ? error.message : 'the Rust checker refused the check');

package/dist/expression/bridge.d.ts

@@ -1,15 +1,16 @@
 import type { Expression } from './types';
 import type { ExprSlot } from '../parser/ast';
+import type { LanguageVersion } from '../language_version';
 import { type MovementCondition } from '../parser/expression/lower';
 import type { MExpr } from '../parser/expression/tree';
 export { BridgeError } from './error';
 export { POSITION_SENTINEL, type MovementCondition } from '../parser/expression/lower';
-export declare function parseMovementExpression(raw: string, languageVersion?: number): Expression;
-export declare function parseMovementCondition(raw: string, languageVersion?: number): MovementCondition;
+export declare function parseMovementExpression(raw: string, languageVersion?: LanguageVersion): Expression;
+export declare function parseMovementCondition(raw: string, languageVersion?: LanguageVersion): MovementCondition;
 /** The slot's tree as the grammar read it, before lowering decides what any
  *  name in it means — what call resolution walks. Throws the slot's syntax
  *  error, as the lowerings below do. */
-export declare function treeOfSlot(slot: ExprSlot, languageVersion?: number): MExpr;
+export declare function treeOfSlot(slot: ExprSlot, languageVersion?: LanguageVersion): MExpr;
 /**
  * A slot whose tree is `tree` — a rewriting of `slot`'s own tree (a nested
  * call replaced by the name it is bound to), or one of its sub-expressions.
@@ -23,9 +24,9 @@ export declare function slotOfTree(slot: ExprSlot, tree: MExpr): ExprSlot;
  *  original's offsets, so a place in one is the same place in the other. */
 export declare function originalSlot(slot: ExprSlot): ExprSlot;
 /** The slot as a value expression. */
-export declare function expressionOfSlot(slot: ExprSlot, languageVersion?: number): Expression;
+export declare function expressionOfSlot(slot: ExprSlot, languageVersion?: LanguageVersion): Expression;
 /** The slot as an `if` condition. */
-export declare function conditionOfSlot(slot: ExprSlot, languageVersion?: number): MovementCondition;
+export declare function conditionOfSlot(slot: ExprSlot, languageVersion?: LanguageVersion): MovementCondition;
 /**
  * A string slot's text for a READER — the story, a diagnostic, a listing.
  * A literal that interpolates has no text until it is evaluated in a firing

package/dist/expression/types.d.ts

@@ -299,10 +299,10 @@ export declare function objectMemberExpression(member: ObjectMember): Expression
 /** An object member rebuilt with `rewrite` applied to its expression. */
 export declare function mapObjectMember(member: ObjectMember, rewrite: (expr: Expression) => Expression): ObjectMember;
 export type Expression = 
-/** `fieldOnly`: a hop's alias read from language version 5 (`m.email`),
+/** `fieldOnly`: a hop's alias read (`m.email`),
  *  always the field of the record the hop lands on. Without it a name in a
  *  hop's WHERE is a variable when one is in scope, else the field (the
- *  reading versions 1–4 keep). A source given the filter reads both as the
+ *  reading the older language keeps). A source given the filter reads both as the
  *  field, as it always has. */
 {
     type: 'property';

package/dist/language_version.d.ts

@@ -1,58 +1,28 @@
 import type { Diagnostic } from './checker/diagnostic';
-/** A language version's identity. */
-export type LanguageVersion = number;
-export interface LanguageVersionInfo {
-    version: LanguageVersion;
-    /** Display only. */
-    name: string;
-    /** What the version is, for release notes and people. */
-    is: string;
-}
-export declare const LANGUAGE_VERSIONS: readonly LanguageVersionInfo[];
-/** What a movement saved today is pinned to, and what an entry point given no
- *  version compiles and runs under. */
-export declare const CURRENT_LANGUAGE_VERSION: LanguageVersion;
-/** The versions this release parses, checks and runs. */
-export declare const SUPPORTED_LANGUAGE_VERSIONS: ReadonlySet<LanguageVersion>;
-/** Supported versions that will be removed: they still run, with a warning. */
-export declare const DEPRECATED_LANGUAGE_VERSIONS: ReadonlySet<LanguageVersion>;
-/** What a release declares about versions. The standing of a pin is a question
- *  asked of a release, so a deploy check can ask it of the next one. */
-export interface LanguageRelease {
-    current: LanguageVersion;
-    supported: ReadonlySet<LanguageVersion>;
-    deprecated: ReadonlySet<LanguageVersion>;
-}
-export declare const THIS_RELEASE: LanguageRelease;
-export declare function languageVersionInfo(version: LanguageVersion): LanguageVersionInfo | undefined;
-/** `"Quiet Heron" (1)` — or `version 7` for an integer this release has never
- *  heard of (a movement saved by a newer release). */
-export declare function describeLanguageVersion(version: LanguageVersion): string;
-/** How a version is shown to a person or an agent: the integer that identifies
- *  it, and its name. */
-export interface LanguageVersionView {
-    version: LanguageVersion;
-    name: string;
-}
-export declare function languageVersionView(version: LanguageVersion): LanguageVersionView;
-export type LanguageVersionStanding = 'supported' | 'deprecated' | 'unsupported';
-export declare function languageVersionStanding(version: LanguageVersion, release?: LanguageRelease): LanguageVersionStanding;
+/** A pin: the release a movement was written against, `MAJOR.MINOR.PATCH[-pre]`. */
+export type LanguageVersion = string;
+/** This release's version, and so the language it reads. */
+export declare const LANGUAGE_VERSION: LanguageVersion;
+export type LanguageVersionStanding = 'compatible' | 'newer' | 'olderKey' | 'malformed';
+/** The part of a version a pin must share with a release; undefined for a
+ *  text that is not a version. */
+export declare function compatibilityKey(version: string): string | undefined;
+/** How `pin` stands against the release `own`. */
+export declare function languageVersionStanding(pin: string, own?: LanguageVersion): LanguageVersionStanding;
+/** Whether the release `own` reads a movement pinned to `pin`. */
+export declare function compatible(pin: string, own?: LanguageVersion): boolean;
 export declare const LanguageVersionDiagnosticCodes: {
     readonly UNSUPPORTED: "MOV_LANGUAGE_VERSION_UNSUPPORTED";
-    readonly DEPRECATED: "MOV_LANGUAGE_VERSION_DEPRECATED";
 };
 /**
- * What a movement pinned to `version` must be told before anything else: an
- * error when this release cannot run it (never a silent fallback to the current
- * version), a warning when it runs but will stop doing so, nothing otherwise.
- * The message names the version and the fix.
+ * What a movement pinned to `pin` must be told before anything else: an error
+ * when this release does not read it (never a silent fallback to the current
+ * version), naming the pin and the remedy; nothing when it does.
  */
-export declare function languageVersionDiagnostic(version: LanguageVersion, release?: LanguageRelease): Diagnostic | undefined;
-/** The run host's units (Henry 2026-10-16): from version 5 every file has
- *  these names in scope, each already connected — `listen to manual fire
- *  hello`, `listen to cron { schedule: "0 9 * * 1" } fire digest` — with no
- *  import and no `connect`. A file's own binding of the name replaces it.
+export declare function languageVersionDiagnostic(pin: string, own?: LanguageVersion): Diagnostic | undefined;
+/** The run host's units (Henry 2026-10-16): every file has these names in
+ *  scope, each already connected — `listen to manual fire hello`,
+ *  `listen to cron { schedule: "0 9 * * 1" } fire digest` — with no import
+ *  and no `connect`. A file's own binding of the name replaces it.
  *  (`RUN_HOST_UNITS` in crates/movement-parser/src/version.rs.) */
 export declare const RUN_HOST_UNITS: readonly string[];
-/** The units a file pinned to `version` has in scope. */
-export declare function runHostUnits(version: LanguageVersion): readonly string[];

package/dist/language_version.js

@@ -1,123 +1,83 @@
 "use strict";
-// Language versions — the one table.
+// The language version is the toolchain release: the one semver every crate
+// and package carries. A movement's pin is the release it was written
+// against, and a release reads a pin whose compatibility key is its own: the
+// minor under 0.x (`0.12`), the major from 1.0 (`1`). Any other pin is refused
+// by name, with the remedy (docs/contracts/language-versions.md).
 //
-// A saved movement is pinned to the language version it was written against,
-// and every layer (parser, checker, engine, plugins, adapters) honours that pin
-// by a conditional at the point of difference:
-//
-//     if (ctx.languageVersion < 2) { …the old behaviour… }
-//
-// The integer is the identity — code compares it and never parses the name.
-// The name is display only: it is what a person sees.
-//
-// A version keeps its row here after it leaves SUPPORTED, so a movement pinned
-// to it can still be refused by name.
-//
-// See plans/language-versioning-2026-09-29/.
+// The same rule is crates/movement-parser/src/version.rs; a test holds the two
+// equal (packages/engine-contracts/__test__/contracts.unit.test.ts).
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RUN_HOST_UNITS = exports.LanguageVersionDiagnosticCodes = exports.THIS_RELEASE = exports.DEPRECATED_LANGUAGE_VERSIONS = exports.SUPPORTED_LANGUAGE_VERSIONS = exports.CURRENT_LANGUAGE_VERSION = exports.LANGUAGE_VERSIONS = void 0;
-exports.languageVersionInfo = languageVersionInfo;
-exports.describeLanguageVersion = describeLanguageVersion;
-exports.languageVersionView = languageVersionView;
+exports.RUN_HOST_UNITS = exports.LanguageVersionDiagnosticCodes = exports.LANGUAGE_VERSION = void 0;
+exports.compatibilityKey = compatibilityKey;
 exports.languageVersionStanding = languageVersionStanding;
+exports.compatible = compatible;
 exports.languageVersionDiagnostic = languageVersionDiagnostic;
-exports.runHostUnits = runHostUnits;
+const language_version_value_1 = require("./language_version_value");
 const never_1 = require("./never");
-exports.LANGUAGE_VERSIONS = [
-    { version: 1, name: 'Quiet Heron', is: 'the language as of tag v0.6.0' },
-    { version: 2, name: 'Bright Otter', is: 'the language from v0.7.0 through v0.9.1' },
-    {
-        version: 3,
-        name: 'Steady Lynx',
-        is: 'the language from v0.10.0: a list literal is a tuple — exact at a literal index, a list of its members\' union elsewhere',
-    },
-    {
-        version: 4,
-        name: 'Luminous Owl',
-        is: 'the language from v0.11.0: a match yields absent on a miss, a write handle reaches its pre-write record through @old',
-    },
-    {
-        version: 5,
-        name: 'Dancing Wren',
-        is: 'the language after v0.11.0: no engine-side store and no meta edges — no `write … bind` (a link lives in the system that holds it), no `#` hops (a plugin is a function you call), `delete` only where the system declares a type deletable, `_resources` only on an extraction\'s result (a record walks its system\'s file edge: `Attachments`, `Files`, `Resources`), a file is never joined into text (its text is `READ(f)`), a closure is a value (a list may hold closures, and a value that is one is called), and `parallel` is retired (`MAP` over the functions, calling each, is the join)',
-    },
-];
-/** What a movement saved today is pinned to, and what an entry point given no
- *  version compiles and runs under. */
-exports.CURRENT_LANGUAGE_VERSION = 5;
-/** The versions this release parses, checks and runs. */
-exports.SUPPORTED_LANGUAGE_VERSIONS = new Set([5]);
-/** Supported versions that will be removed: they still run, with a warning. */
-exports.DEPRECATED_LANGUAGE_VERSIONS = new Set();
-exports.THIS_RELEASE = {
-    current: exports.CURRENT_LANGUAGE_VERSION,
-    supported: exports.SUPPORTED_LANGUAGE_VERSIONS,
-    deprecated: exports.DEPRECATED_LANGUAGE_VERSIONS,
-};
-function languageVersionInfo(version) {
-    return exports.LANGUAGE_VERSIONS.find((info) => info.version === version);
+/** This release's version, and so the language it reads. */
+exports.LANGUAGE_VERSION = language_version_value_1.PACKAGE_VERSION;
+const SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+function parse(version) {
+    const match = SEMVER.exec(version);
+    return match === null ? undefined : { major: Number(match[1]), minor: Number(match[2]) };
 }
-/** `"Quiet Heron" (1)` — or `version 7` for an integer this release has never
- *  heard of (a movement saved by a newer release). */
-function describeLanguageVersion(version) {
-    const info = languageVersionInfo(version);
-    return info ? `"${info.name}" (${info.version})` : `version ${version}`;
+/** The part of a version a pin must share with a release; undefined for a
+ *  text that is not a version. */
+function compatibilityKey(version) {
+    const parsed = parse(version);
+    if (parsed === undefined)
+        return undefined;
+    return parsed.major === 0 ? `0.${parsed.minor}` : String(parsed.major);
 }
-function languageVersionView(version) {
-    return { version, name: languageVersionInfo(version)?.name ?? `version ${version}` };
+/** How `pin` stands against the release `own`. */
+function languageVersionStanding(pin, own = exports.LANGUAGE_VERSION) {
+    const pinned = parse(pin);
+    const release = parse(own);
+    if (pinned === undefined || release === undefined)
+        return 'malformed';
+    if (compatibilityKey(pin) === compatibilityKey(own))
+        return 'compatible';
+    const newer = pinned.major !== release.major ? pinned.major > release.major : pinned.minor > release.minor;
+    return newer ? 'newer' : 'olderKey';
 }
-function languageVersionStanding(version, release = exports.THIS_RELEASE) {
-    if (!release.supported.has(version))
-        return 'unsupported';
-    if (release.deprecated.has(version))
-        return 'deprecated';
-    return 'supported';
+/** Whether the release `own` reads a movement pinned to `pin`. */
+function compatible(pin, own = exports.LANGUAGE_VERSION) {
+    return languageVersionStanding(pin, own) === 'compatible';
 }
 exports.LanguageVersionDiagnosticCodes = {
     UNSUPPORTED: 'MOV_LANGUAGE_VERSION_UNSUPPORTED',
-    DEPRECATED: 'MOV_LANGUAGE_VERSION_DEPRECATED',
 };
-/**
- * What a movement pinned to `version` must be told before anything else: an
- * error when this release cannot run it (never a silent fallback to the current
- * version), a warning when it runs but will stop doing so, nothing otherwise.
- * The message names the version and the fix.
- */
-function languageVersionDiagnostic(version, release = exports.THIS_RELEASE) {
-    const span = { start: { line: 1, col: 1 }, end: { line: 1, col: 1 } };
-    const current = describeLanguageVersion(release.current);
-    const standing = languageVersionStanding(version, release);
+function refusalMessage(pin, own, standing) {
     switch (standing) {
-        case 'supported':
-            return undefined;
-        case 'unsupported':
-            return {
-                code: exports.LanguageVersionDiagnosticCodes.UNSUPPORTED,
-                message: `this automation is written in language version ${describeLanguageVersion(version)}, ` +
-                    `which this release does not support, so it will not validate or run. ` +
-                    `To fix: validate it under ${current}, repair what that reports, and upgrade it to ${current}.`,
-                span,
-            };
-        case 'deprecated':
-            return {
-                code: exports.LanguageVersionDiagnosticCodes.DEPRECATED,
-                message: `this automation is written in language version ${describeLanguageVersion(version)}, ` +
-                    `which is deprecated and will be removed in a future release. ` +
-                    `Validate it under ${current}, repair what that reports, and upgrade it to ${current} before then.`,
-                span,
-                severity: 'warning',
-            };
+        case 'newer':
+            return `this automation pins language ${pin}, newer than this release (${own}); upgrade the engine`;
+        case 'olderKey':
+            return `this automation pins language ${pin}, which this release (${own}) does not read; validate it under ${own} and upgrade it`;
+        case 'malformed':
+            return `this automation pins language ${pin}, which is not a version; a pin is a release's version, such as ${own}`;
         default:
             return (0, never_1.neverAsAny)(standing);
     }
 }
-/** The run host's units (Henry 2026-10-16): from version 5 every file has
- *  these names in scope, each already connected — `listen to manual fire
- *  hello`, `listen to cron { schedule: "0 9 * * 1" } fire digest` — with no
- *  import and no `connect`. A file's own binding of the name replaces it.
+/**
+ * What a movement pinned to `pin` must be told before anything else: an error
+ * when this release does not read it (never a silent fallback to the current
+ * version), naming the pin and the remedy; nothing when it does.
+ */
+function languageVersionDiagnostic(pin, own = exports.LANGUAGE_VERSION) {
+    const standing = languageVersionStanding(pin, own);
+    if (standing === 'compatible')
+        return undefined;
+    return {
+        code: exports.LanguageVersionDiagnosticCodes.UNSUPPORTED,
+        message: refusalMessage(pin, own, standing),
+        span: { start: { line: 1, col: 1 }, end: { line: 1, col: 1 } },
+    };
+}
+/** The run host's units (Henry 2026-10-16): every file has these names in
+ *  scope, each already connected — `listen to manual fire hello`,
+ *  `listen to cron { schedule: "0 9 * * 1" } fire digest` — with no import
+ *  and no `connect`. A file's own binding of the name replaces it.
  *  (`RUN_HOST_UNITS` in crates/movement-parser/src/version.rs.) */
 exports.RUN_HOST_UNITS = ['cron', 'manual'];
-/** The units a file pinned to `version` has in scope. */
-function runHostUnits(version) {
-    return version >= 5 ? exports.RUN_HOST_UNITS : [];
-}

package/dist/language_version_value.d.ts

@@ -0,0 +1 @@
+export declare const PACKAGE_VERSION = "0.12.0-rc.7";

package/dist/language_version_value.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PACKAGE_VERSION = void 0;
+// The package's version, written here from package.json by
+// scripts/build-packages.cjs (a source and its build sit at different depths
+// beside package.json, so neither can require it by one relative path).
+// __test__/language_version.unit.test.ts holds it equal to package.json.
+exports.PACKAGE_VERSION = '0.12.0-rc.7';