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

package/dist/protocol.d.ts

@@ -1548,8 +1548,11 @@ 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. */
+export declare const CORE_SLOTS: readonly ["models", "judge", "store", "files", "limiter", "loopGuard", "browser", "wake", "ocr", "secrets"];
 export declare const WireCoreSlot: z.ZodEnum<{
     store: "store";
     models: "models";
@@ -1560,6 +1563,7 @@ export declare const WireCoreSlot: z.ZodEnum<{
     browser: "browser";
     wake: "wake";
     ocr: "ocr";
+    secrets: "secrets";
 }>;
 export type WireCoreSlotShape = z.infer<typeof WireCoreSlot>;
 /** One construction argument the install supplies (an Airtable `base`, a
@@ -1618,6 +1622,7 @@ export declare const WireModuleDeclarations: z.ZodObject<{
         browser: "browser";
         wake: "wake";
         ocr: "ocr";
+        secrets: "secrets";
     }>>;
     settings: z.ZodOptional<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
@@ -1759,6 +1764,7 @@ export declare const WireManifestResult: z.ZodObject<{
         browser: "browser";
         wake: "wake";
         ocr: "ocr";
+        secrets: "secrets";
     }>>;
     settings: z.ZodOptional<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
@@ -2260,6 +2266,7 @@ export declare const METHODS: {
                 browser: "browser";
                 wake: "wake";
                 ocr: "ocr";
+                secrets: "secrets";
             }>>;
             settings: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 name: z.ZodString;

package/dist/protocol.js

@@ -738,8 +738,11 @@ 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. */
+exports.CORE_SLOTS = ['models', 'judge', 'store', 'files', 'limiter', 'loopGuard', 'browser', 'wake', 'ocr', 'secrets'];
 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`,

package/dist/slots/index.d.ts

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

package/dist/slots/index.js

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

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,7 @@ export declare const WireSlotManifest: z.ZodObject<{
         browser: "browser";
         wake: "wake";
         ocr: "ocr";
+        secrets: "secrets";
     }>;
     methods: z.ZodArray<z.ZodString>;
 }, z.core.$strip>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@listen-fire/engine-contracts",
   "license": "Apache-2.0",
-  "version": "0.12.0-rc.7",
+  "version": "0.12.0-rc.8",
   "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"
@@ -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-rc.8"
   },
   "devDependencies": {
     "@types/node": "20.16.5",