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

package/dist/protocol.d.ts

@@ -1423,6 +1423,9 @@ export declare const WireSignedInboundDeclaration: z.ZodObject<{
         installer: "installer";
         provider: "provider";
     }>>;
+    deliveryId: z.ZodOptional<z.ZodObject<{
+        header: z.ZodString;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 /**
  * The module checks its own inbound requests (`scheme: module`): the host
@@ -1457,6 +1460,9 @@ export declare const WireInboundDeclaration: z.ZodDiscriminatedUnion<[z.ZodObjec
         installer: "installer";
         provider: "provider";
     }>>;
+    deliveryId: z.ZodOptional<z.ZodObject<{
+        header: z.ZodString;
+    }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     providerKey: z.ZodString;
     scheme: z.ZodLiteral<"module">;
@@ -1548,8 +1554,13 @@ export type WireModuleKindShape = z.infer<typeof WireModuleKind>;
  *  other host leaves empty (a module asking for a page is refused by name),
  *  and `wake`, which stays empty unless named (nobody is told work is due;
  *  a scheduled worker finds it), and `ocr`, which stays empty unless named
- *  (a scanned file is refused, saying the slot is empty). */
-export declare const CORE_SLOTS: readonly ["models", "judge", "store", "files", "limiter", "loopGuard", "browser", "wake", "ocr"];
+ *  (a scanned file is refused, saying the slot is empty). `secrets` is
+ *  where credentials are kept (`lf`'s default: its secrets file); a secrets
+ *  module's own settings come from the environment or that file, never
+ *  from itself. `movements` answers the project's movement files by name
+ *  (`lf`'s default: the movements folder); its module's own settings come
+ *  from the same two places. */
+export declare const CORE_SLOTS: readonly ["models", "judge", "store", "files", "limiter", "loopGuard", "browser", "wake", "ocr", "secrets", "movements"];
 export declare const WireCoreSlot: z.ZodEnum<{
     store: "store";
     models: "models";
@@ -1560,6 +1571,8 @@ export declare const WireCoreSlot: z.ZodEnum<{
     browser: "browser";
     wake: "wake";
     ocr: "ocr";
+    secrets: "secrets";
+    movements: "movements";
 }>;
 export type WireCoreSlotShape = z.infer<typeof WireCoreSlot>;
 /** One construction argument the install supplies (an Airtable `base`, a
@@ -1618,6 +1631,8 @@ export declare const WireModuleDeclarations: z.ZodObject<{
         browser: "browser";
         wake: "wake";
         ocr: "ocr";
+        secrets: "secrets";
+        movements: "movements";
     }>>;
     settings: z.ZodOptional<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
@@ -1676,6 +1691,9 @@ export declare const WireModuleDeclarations: z.ZodObject<{
             installer: "installer";
             provider: "provider";
         }>>;
+        deliveryId: z.ZodOptional<z.ZodObject<{
+            header: z.ZodString;
+        }, z.core.$strip>>;
     }, z.core.$strip>, z.ZodObject<{
         providerKey: z.ZodString;
         scheme: z.ZodLiteral<"module">;
@@ -1759,6 +1777,8 @@ export declare const WireManifestResult: z.ZodObject<{
         browser: "browser";
         wake: "wake";
         ocr: "ocr";
+        secrets: "secrets";
+        movements: "movements";
     }>>;
     settings: z.ZodOptional<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
@@ -1817,6 +1837,9 @@ export declare const WireManifestResult: z.ZodObject<{
             installer: "installer";
             provider: "provider";
         }>>;
+        deliveryId: z.ZodOptional<z.ZodObject<{
+            header: z.ZodString;
+        }, z.core.$strip>>;
     }, z.core.$strip>, z.ZodObject<{
         providerKey: z.ZodString;
         scheme: z.ZodLiteral<"module">;
@@ -2064,6 +2087,7 @@ export declare const WireInboundCheck: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }, z.core.$strip>>;
     wakeKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
     checkpoint: z.ZodOptional<z.ZodUnknown>;
+    deliveryId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     outcome: z.ZodLiteral<"refused">;
     status: z.ZodOptional<z.ZodNumber>;
@@ -2092,6 +2116,7 @@ export declare const HostModelRequest: z.ZodObject<{
     schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     toolName: z.ZodOptional<z.ZodString>;
     toolDescription: z.ZodOptional<z.ZodString>;
+    runId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type HostModelRequestShape = z.infer<typeof HostModelRequest>;
 /** The tokens a model call spent: what a run's usage reports, beside its cost. */
@@ -2260,6 +2285,8 @@ export declare const METHODS: {
                 browser: "browser";
                 wake: "wake";
                 ocr: "ocr";
+                secrets: "secrets";
+                movements: "movements";
             }>>;
             settings: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 name: z.ZodString;
@@ -2318,6 +2345,9 @@ export declare const METHODS: {
                     installer: "installer";
                     provider: "provider";
                 }>>;
+                deliveryId: z.ZodOptional<z.ZodObject<{
+                    header: z.ZodString;
+                }, z.core.$strip>>;
             }, z.core.$strip>, z.ZodObject<{
                 providerKey: z.ZodString;
                 scheme: z.ZodLiteral<"module">;
@@ -3775,6 +3805,7 @@ export declare const METHODS: {
             }, z.core.$strip>>;
             wakeKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
             checkpoint: z.ZodOptional<z.ZodUnknown>;
+            deliveryId: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>, z.ZodObject<{
             outcome: z.ZodLiteral<"refused">;
             status: z.ZodOptional<z.ZodNumber>;

package/dist/protocol.js

@@ -664,6 +664,10 @@ exports.WireSignedInboundDeclaration = zod_1.z.object({
         .min(1),
     intercepts: zod_1.z.array(exports.WireInboundIntercept).optional(),
     secretIssuedBy: WireSecretIssuedBy.optional(),
+    /** The header carrying the provider's id for each delivery (GitHub's
+     *  `x-github-delivery`), read by the host before the module sees the body:
+     *  a redelivery under an id the host kept before is acked and runs nothing. */
+    deliveryId: zod_1.z.object({ header: zod_1.z.string().regex(HEADER_NAME, 'a delivery id header is a lower-case header name') }).optional(),
 });
 /**
  * The module checks its own inbound requests (`scheme: module`): the host
@@ -738,8 +742,13 @@ exports.WireModuleKind = zod_1.z.enum(exports.MODULE_KINDS);
  *  other host leaves empty (a module asking for a page is refused by name),
  *  and `wake`, which stays empty unless named (nobody is told work is due;
  *  a scheduled worker finds it), and `ocr`, which stays empty unless named
- *  (a scanned file is refused, saying the slot is empty). */
-exports.CORE_SLOTS = ['models', 'judge', 'store', 'files', 'limiter', 'loopGuard', 'browser', 'wake', 'ocr'];
+ *  (a scanned file is refused, saying the slot is empty). `secrets` is
+ *  where credentials are kept (`lf`'s default: its secrets file); a secrets
+ *  module's own settings come from the environment or that file, never
+ *  from itself. `movements` answers the project's movement files by name
+ *  (`lf`'s default: the movements folder); its module's own settings come
+ *  from the same two places. */
+exports.CORE_SLOTS = ['models', 'judge', 'store', 'files', 'limiter', 'loopGuard', 'browser', 'wake', 'ocr', 'secrets', 'movements'];
 exports.WireCoreSlot = zod_1.z.enum(exports.CORE_SLOTS);
 /** One construction argument the install supplies (an Airtable `base`, a
  *  Sheets `spreadsheet`): asked for when the module is set up (`lf connect`,
@@ -926,6 +935,9 @@ exports.WireInboundCheck = zod_1.z.discriminatedUnion('outcome', [
         events: zod_1.z.array(exports.WireDiscriminableEvent),
         wakeKeys: zod_1.z.array(zod_1.z.string().min(1)).optional(),
         checkpoint: zod_1.z.unknown().optional(),
+        /** The provider's id for this delivery: a redelivery under an id the
+         *  host kept before is acked and runs nothing. */
+        deliveryId: zod_1.z.string().min(1).optional(),
     }),
     zod_1.z.object({
         outcome: zod_1.z.literal('refused'),
@@ -953,6 +965,8 @@ exports.HostModelRequest = zod_1.z.object({
     schema: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
     toolName: zod_1.z.string().optional(),
     toolDescription: zod_1.z.string().optional(),
+    /** The run the call is made for, when it is made inside one: a host's usage rows attribute the call to it. */
+    runId: zod_1.z.string().optional(),
 });
 /** The tokens a model call spent: what a run's usage reports, beside its cost. */
 exports.WireModelUsage = zod_1.z.object({

package/dist/slots/index.d.ts

@@ -5,3 +5,5 @@ export * from './files';
 export * from './browser';
 export * from './wake';
 export * from './ocr';
+export * from './secrets';
+export * from './movements';

package/dist/slots/index.js

@@ -24,3 +24,5 @@ __exportStar(require("./files"), exports);
 __exportStar(require("./browser"), exports);
 __exportStar(require("./wake"), exports);
 __exportStar(require("./ocr"), exports);
+__exportStar(require("./secrets"), exports);
+__exportStar(require("./movements"), exports);

package/dist/slots/models.d.ts

@@ -10,6 +10,7 @@ export declare const ModelsCallRequest: z.ZodObject<{
     schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     toolName: z.ZodOptional<z.ZodString>;
     toolDescription: z.ZodOptional<z.ZodString>;
+    runId: z.ZodOptional<z.ZodString>;
     effort: z.ZodOptional<z.ZodEnum<{
         low: "low";
         medium: "medium";

package/dist/slots/movements.d.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+export declare const MOVEMENTS_METHODS: readonly ["movements.list", "movements.read", "movements.write"];
+/** A file's path under the movements folder: `/`-separated, ending `.mvt`,
+ *  no segment empty, `.` or `..`, and no `\` (`orders/sync.mvt`). */
+export declare const MovementPath: z.ZodString;
+export declare function isMovementPath(path: string): boolean;
+/** One file `movements.list` names; without a version, `lf` reads it on every scan. */
+export declare const MovementsListed: z.ZodObject<{
+    path: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const MovementsListAnswer: z.ZodArray<z.ZodObject<{
+    path: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+/** What `movements.read` answers (or null: nothing is at the path). */
+export declare const MovementsReadAnswer: z.ZodNullable<z.ZodObject<{
+    text: z.ZodString;
+    version: z.ZodString;
+}, z.core.$strip>>;
+export declare const MovementsReadRequest: z.ZodObject<{
+    path: z.ZodString;
+}, z.core.$strip>;
+/** `expectedVersion` is present: a version replaces the file only if it is
+ *  still at it; null creates it only if nothing is at the path. */
+export declare const MovementsWriteRequest: z.ZodObject<{
+    path: z.ZodString;
+    text: z.ZodString;
+    expectedVersion: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const MovementsWriteAnswer: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"written">;
+    version: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"conflict">;
+    current: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"read_only">;
+    reason: z.ZodString;
+}, z.core.$strip>], "kind">;
+export type MovementsWriteAnswerShape = z.infer<typeof MovementsWriteAnswer>;

package/dist/slots/movements.js

@@ -0,0 +1,38 @@
+"use strict";
+// The movements slot's methods (docs/contracts/movements-slot.md): where the
+// project's movement files live. A module lists every file by its path under
+// the movements folder, reads one, and writes one by compare-and-swap on its
+// version. `lf.yaml` and the externals folder stay local files.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MovementsWriteAnswer = exports.MovementsWriteRequest = exports.MovementsReadRequest = exports.MovementsReadAnswer = exports.MovementsListAnswer = exports.MovementsListed = exports.MovementPath = exports.MOVEMENTS_METHODS = void 0;
+exports.isMovementPath = isMovementPath;
+const zod_1 = require("zod");
+exports.MOVEMENTS_METHODS = ['movements.list', 'movements.read', 'movements.write'];
+/** A file's path under the movements folder: `/`-separated, ending `.mvt`,
+ *  no segment empty, `.` or `..`, and no `\` (`orders/sync.mvt`). */
+exports.MovementPath = zod_1.z.string().refine(isMovementPath, 'a movement path: relative to the movements folder, `/`-separated, ending .mvt');
+function isMovementPath(path) {
+    const segments = path.split('/');
+    return (!path.includes('\\') &&
+        path.endsWith('.mvt') &&
+        segments.every((segment) => segment !== '' && segment !== '.' && segment !== '..') &&
+        segments.at(-1) !== '.mvt');
+}
+/** Opaque; it changes whenever the text changes. */
+const Version = zod_1.z.string().min(1);
+/** One file `movements.list` names; without a version, `lf` reads it on every scan. */
+exports.MovementsListed = zod_1.z.object({ path: exports.MovementPath, version: Version.optional() });
+exports.MovementsListAnswer = zod_1.z.array(exports.MovementsListed);
+/** What `movements.read` answers (or null: nothing is at the path). */
+exports.MovementsReadAnswer = zod_1.z.object({ text: zod_1.z.string(), version: Version }).nullable();
+exports.MovementsReadRequest = zod_1.z.object({ path: exports.MovementPath });
+/** `expectedVersion` is present: a version replaces the file only if it is
+ *  still at it; null creates it only if nothing is at the path. */
+exports.MovementsWriteRequest = zod_1.z.object({ path: exports.MovementPath, text: zod_1.z.string(), expectedVersion: Version.nullable() });
+exports.MovementsWriteAnswer = zod_1.z.discriminatedUnion('kind', [
+    zod_1.z.object({ kind: zod_1.z.literal('written'), version: Version }),
+    /** `current`: the version there now, or null when there is none. */
+    zod_1.z.object({ kind: zod_1.z.literal('conflict'), current: Version.nullable() }),
+    /** The module keeps the project's movements where `lf` cannot change them. */
+    zod_1.z.object({ kind: zod_1.z.literal('read_only'), reason: zod_1.z.string().min(1) }),
+]);

package/dist/slots/secrets.d.ts

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+export declare const SECRETS_METHODS: readonly ["secrets.resolve", "secrets.writeBack", "secrets.list", "secrets.lock", "secrets.unlock", "secrets.assertWritable", "secrets.create", "secrets.replace", "secrets.delete"];
+/** What `secrets.resolve` answers (or null: nothing is stored under the ref). */
+export declare const SecretsRecord: z.ZodObject<{
+    fields: z.ZodRecord<z.ZodString, z.ZodString>;
+    version: z.ZodString;
+}, z.core.$strip>;
+export declare const SecretsWriteBackAnswer: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"written">;
+    record: z.ZodObject<{
+        fields: z.ZodRecord<z.ZodString, z.ZodString>;
+        version: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"not_persisted">;
+    record: z.ZodObject<{
+        fields: z.ZodRecord<z.ZodString, z.ZodString>;
+        version: z.ZodString;
+    }, z.core.$strip>;
+    why: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"conflict">;
+    current: z.ZodObject<{
+        fields: z.ZodRecord<z.ZodString, z.ZodString>;
+        version: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"missing">;
+}, z.core.$strip>], "kind">;
+/** How an entry is bound: an install of a module, a hand-written legacy
+ *  entry, or a credential the module declares. */
+export declare const SecretsBinding: z.ZodUnion<readonly [z.ZodLiteral<"install">, z.ZodLiteral<"legacy">, z.ZodObject<{
+    credential: z.ZodString;
+}, z.core.$strip>]>;
+export type SecretsBindingShape = z.infer<typeof SecretsBinding>;
+export declare const SecretsListed: z.ZodObject<{
+    ref: z.ZodString;
+    external: z.ZodString;
+    binding: z.ZodUnion<readonly [z.ZodLiteral<"install">, z.ZodLiteral<"legacy">, z.ZodObject<{
+        credential: z.ZodString;
+    }, z.core.$strip>]>;
+    version: z.ZodString;
+}, z.core.$strip>;
+/** `secrets.lock` answers a token, or null when another holds the lease. */
+export declare const SecretsLockAnswer: z.ZodNullable<z.ZodObject<{
+    token: z.ZodString;
+}, z.core.$strip>>;
+/** What `secrets.assertWritable`, `create`, `replace` and `delete` answer
+ *  besides null: the module keeps its credentials where lf cannot change them. */
+export declare const SecretsReadOnlyAnswer: z.ZodObject<{
+    kind: z.ZodLiteral<"read_only">;
+    reason: z.ZodString;
+}, z.core.$strip>;
+export declare const SecretsEntryAnswer: z.ZodNullable<z.ZodObject<{
+    kind: z.ZodLiteral<"read_only">;
+    reason: z.ZodString;
+}, z.core.$strip>>;
+export declare const SecretsEntryRequest: z.ZodObject<{
+    ref: z.ZodString;
+    external: z.ZodString;
+    binding: z.ZodUnion<readonly [z.ZodLiteral<"install">, z.ZodLiteral<"legacy">, z.ZodObject<{
+        credential: z.ZodString;
+    }, z.core.$strip>]>;
+    fields: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strip>;

package/dist/slots/secrets.js

@@ -0,0 +1,40 @@
+"use strict";
+// The secrets slot's methods (docs/contracts/secrets-slot.md): where lf's
+// credentials are kept. A module resolves and lists what it holds, takes a
+// write-back by version, holds a credential under a lease while a refresh
+// spends its token, and changes whole entries for `lf connect` and
+// `lf credential`. Token refresh stays in lf; a module only stores.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecretsEntryRequest = exports.SecretsEntryAnswer = exports.SecretsReadOnlyAnswer = exports.SecretsLockAnswer = exports.SecretsListed = exports.SecretsBinding = exports.SecretsWriteBackAnswer = exports.SecretsRecord = exports.SECRETS_METHODS = void 0;
+const zod_1 = require("zod");
+exports.SECRETS_METHODS = [
+    'secrets.resolve',
+    'secrets.writeBack',
+    'secrets.list',
+    'secrets.lock',
+    'secrets.unlock',
+    'secrets.assertWritable',
+    'secrets.create',
+    'secrets.replace',
+    'secrets.delete',
+];
+const Fields = zod_1.z.record(zod_1.z.string(), zod_1.z.string());
+/** What `secrets.resolve` answers (or null: nothing is stored under the ref). */
+exports.SecretsRecord = zod_1.z.object({ fields: Fields, version: zod_1.z.string().min(1) });
+exports.SecretsWriteBackAnswer = zod_1.z.discriminatedUnion('kind', [
+    zod_1.z.object({ kind: zod_1.z.literal('written'), record: exports.SecretsRecord }),
+    zod_1.z.object({ kind: zod_1.z.literal('not_persisted'), record: exports.SecretsRecord, why: zod_1.z.string() }),
+    zod_1.z.object({ kind: zod_1.z.literal('conflict'), current: exports.SecretsRecord }),
+    zod_1.z.object({ kind: zod_1.z.literal('missing') }),
+]);
+/** How an entry is bound: an install of a module, a hand-written legacy
+ *  entry, or a credential the module declares. */
+exports.SecretsBinding = zod_1.z.union([zod_1.z.literal('install'), zod_1.z.literal('legacy'), zod_1.z.object({ credential: zod_1.z.string().min(1) })]);
+exports.SecretsListed = zod_1.z.object({ ref: zod_1.z.string().min(1), external: zod_1.z.string().min(1), binding: exports.SecretsBinding, version: zod_1.z.string() });
+/** `secrets.lock` answers a token, or null when another holds the lease. */
+exports.SecretsLockAnswer = zod_1.z.object({ token: zod_1.z.string().min(1) }).nullable();
+/** What `secrets.assertWritable`, `create`, `replace` and `delete` answer
+ *  besides null: the module keeps its credentials where lf cannot change them. */
+exports.SecretsReadOnlyAnswer = zod_1.z.object({ kind: zod_1.z.literal('read_only'), reason: zod_1.z.string().min(1) });
+exports.SecretsEntryAnswer = exports.SecretsReadOnlyAnswer.nullable();
+exports.SecretsEntryRequest = zod_1.z.object({ ref: zod_1.z.string().min(1), external: zod_1.z.string().min(1), binding: exports.SecretsBinding, fields: Fields });

package/dist/slots/wire.d.ts

@@ -39,6 +39,8 @@ export declare const WireSlotManifest: z.ZodObject<{
         browser: "browser";
         wake: "wake";
         ocr: "ocr";
+        secrets: "secrets";
+        movements: "movements";
     }>;
     methods: z.ZodArray<z.ZodString>;
 }, z.core.$strip>;

package/dist/versions.d.ts

@@ -1,5 +1,6 @@
-import { CATALOG_SNAPSHOT_VERSION, DEPRECATED_CATALOG_SNAPSHOT_VERSIONS, SUPPORTED_CATALOG_SNAPSHOT_VERSIONS } from '@listen-fire/movement-lang';
+import { CATALOG_SNAPSHOT_VERSION, DEPRECATED_CATALOG_SNAPSHOT_VERSIONS, STORY_ANALYSIS_VERSION, SUPPORTED_CATALOG_SNAPSHOT_VERSIONS, SUPPORTED_STORY_ANALYSIS_VERSIONS } from '@listen-fire/movement-lang';
 export { CATALOG_SNAPSHOT_VERSION, DEPRECATED_CATALOG_SNAPSHOT_VERSIONS, SUPPORTED_CATALOG_SNAPSHOT_VERSIONS };
+export { STORY_ANALYSIS_VERSION, SUPPORTED_STORY_ANALYSIS_VERSIONS };
 /** A parked flow's state (docs/contracts/park-state.md). Engine to engine: a
  *  host stores it and hands it back. Version 2 is the Rust engine's; the earlier
  *  TypeScript engine wrote and read 1. */
@@ -47,6 +48,11 @@ export declare const CONTRACTS: {
         readonly supported: readonly [1];
         readonly deprecated: readonly [];
     };
+    readonly 'story-analysis': {
+        readonly current: 1;
+        readonly supported: readonly number[];
+        readonly deprecated: readonly [];
+    };
 };
 /** The language's contract (docs/contracts/language-versions.md) is not an
  *  integer of its own: it is the release's version, and a release reads the

package/dist/versions.js

@@ -8,13 +8,15 @@
 // the version at the point of difference, never by a forked reader. A version
 // this release does not support is refused at the boundary, loudly.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LANGUAGE_CONTRACT = exports.CONTRACTS = exports.SYSTEM_CALLER_VERSION = exports.SUPPORTED_HOST_FAMILIES_VERSIONS = exports.HOST_FAMILIES_VERSION = exports.SUPPORTED_PARK_STATE_VERSIONS = exports.PARK_STATE_VERSION = exports.SUPPORTED_CATALOG_SNAPSHOT_VERSIONS = exports.DEPRECATED_CATALOG_SNAPSHOT_VERSIONS = exports.CATALOG_SNAPSHOT_VERSION = void 0;
+exports.LANGUAGE_CONTRACT = exports.CONTRACTS = exports.SYSTEM_CALLER_VERSION = exports.SUPPORTED_HOST_FAMILIES_VERSIONS = exports.HOST_FAMILIES_VERSION = exports.SUPPORTED_PARK_STATE_VERSIONS = exports.PARK_STATE_VERSION = exports.SUPPORTED_STORY_ANALYSIS_VERSIONS = exports.STORY_ANALYSIS_VERSION = exports.SUPPORTED_CATALOG_SNAPSHOT_VERSIONS = exports.DEPRECATED_CATALOG_SNAPSHOT_VERSIONS = exports.CATALOG_SNAPSHOT_VERSION = void 0;
 exports.refuseUnsupportedHostFamiliesVersion = refuseUnsupportedHostFamiliesVersion;
 exports.refuseUnsupportedParkStateVersion = refuseUnsupportedParkStateVersion;
 const movement_lang_1 = require("@listen-fire/movement-lang");
 Object.defineProperty(exports, "CATALOG_SNAPSHOT_VERSION", { enumerable: true, get: function () { return movement_lang_1.CATALOG_SNAPSHOT_VERSION; } });
 Object.defineProperty(exports, "DEPRECATED_CATALOG_SNAPSHOT_VERSIONS", { enumerable: true, get: function () { return movement_lang_1.DEPRECATED_CATALOG_SNAPSHOT_VERSIONS; } });
+Object.defineProperty(exports, "STORY_ANALYSIS_VERSION", { enumerable: true, get: function () { return movement_lang_1.STORY_ANALYSIS_VERSION; } });
 Object.defineProperty(exports, "SUPPORTED_CATALOG_SNAPSHOT_VERSIONS", { enumerable: true, get: function () { return movement_lang_1.SUPPORTED_CATALOG_SNAPSHOT_VERSIONS; } });
+Object.defineProperty(exports, "SUPPORTED_STORY_ANALYSIS_VERSIONS", { enumerable: true, get: function () { return movement_lang_1.SUPPORTED_STORY_ANALYSIS_VERSIONS; } });
 const protocol_1 = require("./protocol");
 /** A parked flow's state (docs/contracts/park-state.md). Engine to engine: a
  *  host stores it and hands it back. Version 2 is the Rust engine's; the earlier
@@ -46,6 +48,8 @@ exports.CONTRACTS = {
     },
     'adapter-protocol': { current: protocol_1.MANIFEST_PROTOCOL_VERSION, supported: [protocol_1.MANIFEST_PROTOCOL_VERSION], deprecated: [] },
     'system-caller': { current: exports.SYSTEM_CALLER_VERSION, supported: [exports.SYSTEM_CALLER_VERSION], deprecated: [] },
+    // The shape of what the check settled, for a surface that draws a movement's story (docs/contracts/story-analysis.md).
+    'story-analysis': { current: movement_lang_1.STORY_ANALYSIS_VERSION, supported: [...movement_lang_1.SUPPORTED_STORY_ANALYSIS_VERSIONS], deprecated: [] },
 };
 /** The language's contract (docs/contracts/language-versions.md) is not an
  *  integer of its own: it is the release's version, and a release reads the

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@listen-fire/engine-contracts",
   "license": "Apache-2.0",
-  "version": "0.12.0-rc.7",
+  "version": "0.12.0",
   "description": "The contracts the movement engine speaks: the tenant id, the host families and entry-point inputs, the parked state, file descriptors, the adapter protocol, the adapter contract and its manifest, the catalog's schema types and positions, the Expression vocabulary, plugins as data and the model names. Runtime-neutral: no Node import, no ambient types.",
   "engines": {
-    "node": "22.20.0"
+    "node": ">=22.23.4 <23"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -30,7 +30,7 @@
   "type": "commonjs",
   "dependencies": {
     "zod": "4.1.12",
-    "@listen-fire/movement-lang": "^0.12.0-rc.7"
+    "@listen-fire/movement-lang": "^0.12.0"
   },
   "devDependencies": {
     "@types/node": "20.16.5",
@@ -45,8 +45,7 @@
     "dist"
   ],
   "publishConfig": {
-    "access": "public",
-    "tag": "next"
+    "access": "public"
   },
   "scripts": {
     "code:type-check": "tsc --pretty --noEmit && node __embed_smoke__/check.cjs",