@eir-labs/coltrane 0.10.0 → 0.11.0

package/dist/src/genome_schema.d.ts

@@ -965,7 +965,7 @@ export type LineageRecordRefOutput = z.output<typeof LineageRecordRefSchema>;
  *  `evidence_grade` types the distinction the diplomatics tradition draws and this codebase had
  *  only ever narrated: ARCHIVE — the primary was fetched, and `retrieved_at` says when — versus
  *  ATTESTATION — someone declared it. The grade is recorded and never laundered upward. */
-export declare const CitationSchema: z.ZodEffects<z.ZodObject<{
+export declare const CitationSchema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
     /** Author names as cited, e.g. "Crawford, S.E.S.". At least one — an anonymous citation is a rumour. */
     authors: z.ZodArray<z.ZodString, "many">;
     year: z.ZodNumber;
@@ -1020,6 +1020,26 @@ export declare const CitationSchema: z.ZodEffects<z.ZodObject<{
     doi?: string | undefined;
     url?: string | undefined;
     retrieved_at?: string | undefined;
+}>, {
+    authors: string[];
+    year: number;
+    title: string;
+    venue: string;
+    evidence_grade: "archive" | "attestation";
+    locator?: string | undefined;
+    doi?: string | undefined;
+    url?: string | undefined;
+    retrieved_at?: string | undefined;
+}, {
+    authors: string[];
+    year: number;
+    title: string;
+    venue: string;
+    evidence_grade: "archive" | "attestation";
+    locator?: string | undefined;
+    doi?: string | undefined;
+    url?: string | undefined;
+    retrieved_at?: string | undefined;
 }>;
 /** How a genome schema class stands to the published work behind it.
  *
@@ -1042,7 +1062,7 @@ export declare const SchemaAttributionSchema: z.ZodObject<{
     subject: z.ZodString;
     relation: z.ZodEnum<["descends-from", "aligns-with", "diverges-from", "supersedes", "informed-by"]>;
     what_taken: z.ZodString;
-    citation: z.ZodEffects<z.ZodObject<{
+    citation: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         /** Author names as cited, e.g. "Crawford, S.E.S.". At least one — an anonymous citation is a rumour. */
         authors: z.ZodArray<z.ZodString, "many">;
         year: z.ZodNumber;
@@ -1097,6 +1117,26 @@ export declare const SchemaAttributionSchema: z.ZodObject<{
         doi?: string | undefined;
         url?: string | undefined;
         retrieved_at?: string | undefined;
+    }>, {
+        authors: string[];
+        year: number;
+        title: string;
+        venue: string;
+        evidence_grade: "archive" | "attestation";
+        locator?: string | undefined;
+        doi?: string | undefined;
+        url?: string | undefined;
+        retrieved_at?: string | undefined;
+    }, {
+        authors: string[];
+        year: number;
+        title: string;
+        venue: string;
+        evidence_grade: "archive" | "attestation";
+        locator?: string | undefined;
+        doi?: string | undefined;
+        url?: string | undefined;
+        retrieved_at?: string | undefined;
     }>;
 }, "strict", z.ZodTypeAny, {
     subject: string;
@@ -2269,7 +2309,214 @@ export declare const VenueLifecycleSchema: z.ZodObject<{
     policy?: "ephemeral" | "standing" | undefined;
     rebuild_cadence?: string | undefined;
 }>;
-export declare const VenueSchema: z.ZodObject<{
+/** The CLOSED set of device KINDS a room may ask a host for — a class, never a path. A contract that
+ *  could name a raw device path could name the raw memory device (`/dev/mem`) or a whole block
+ *  device, which is a host compromise submitted as a hardware request; the concrete nodes are the
+ *  machine's business, mapped from the class at realization. Validated at the VALUE level so a path
+ *  is refused by name (on `devices`), not merely as an unknown key. */
+export declare const VenueDeviceClassSchema: z.ZodEnum<["audio", "gpio", "i2c", "serial", "spi", "video"]>;
+export declare const DEVICE_CLASSES: ["audio", "gpio", "i2c", "serial", "spi", "video"];
+/** One MCP server a room stands up: a slug, a transport, the launch command, and which credential
+ *  CLASSES it needs (never material). Modelled on what a room declares and deliberately NOT
+ *  `.strict()`, so a future transport-specific field is an addition rather than a breaking change —
+ *  the sub-schema is inferred from the contract's own shape, not a formally frozen surface. */
+export declare const VenueMcpServerSchema: z.ZodObject<{
+    slug: z.ZodString;
+    transport: z.ZodString;
+    command: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** The endpoint an over-the-wire transport (e.g. `sse`) connects to. Absent for a `stdio` server,
+     *  which is reached by its `command` instead — the per-transport requirement is stated once, in the
+     *  cross-field rule on `VenueSchema`, so both doors (the loader and venue_define) enforce it. */
+    url: z.ZodOptional<z.ZodString>;
+    credential_names: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    slug: string;
+    transport: string;
+    command: string[];
+    credential_names: string[];
+    url?: string | undefined;
+}, {
+    slug: string;
+    transport: string;
+    url?: string | undefined;
+    command?: string[] | undefined;
+    credential_names?: string[] | undefined;
+}>;
+export declare const VenueObjectSchema: z.ZodObject<{
+    slug: z.ZodString;
+    /** Exactly one owning institution. The institution is the duty holder; the office below is the
+     *  appointed accountable individual. */
+    institution_slug: z.ZodString;
+    /** Why this room is shaped the way it is — read at review, never at runtime. */
+    description: z.ZodOptional<z.ZodString>;
+    /** The base kind of room (e.g. "ingest-empty", "code-work"). A label for humans and for
+     *  "which room does this work want", not a resolvable reference. */
+    flavor: z.ZodOptional<z.ZodString>;
+    /** Defaulted, not required, and the default is the EMPTY room. Every access-shaped field here
+     *  leans the same way: absent doors reach nothing, absent installs install nothing, an absent
+     *  credential surface permits nothing. A venue that forgot to state its equipment must hold
+     *  nothing rather than hold whatever the reader assumed — and both doors into this class (the
+     *  loader and venue_define) get that from the one schema rather than from two agreeing habits. */
+    equipment: z.ZodDefault<z.ZodObject<{
+        tools: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        tools: string[];
+    }, {
+        tools?: string[] | undefined;
+    }>>;
+    doors: z.ZodOptional<z.ZodObject<{
+        ingress: z.ZodDefault<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+        egress: z.ZodDefault<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        ingress: string[];
+        egress: string[];
+    }, {
+        ingress?: string[] | undefined;
+        egress?: string[] | undefined;
+    }>>;
+    /** Digest-pinned software the room contains. */
+    installs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Which CLASSES of credential may legitimately be present, by name. Never material, and never
+     *  a field material could occupy: a room that declares nothing here is a room where finding a
+     *  credential is a breach rather than a configuration difference. */
+    credential_surface: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    lifecycle: z.ZodDefault<z.ZodObject<{
+        policy: z.ZodDefault<z.ZodEnum<["ephemeral", "standing"]>>;
+        /** ISO-8601 duration or cron-shaped cadence — read by the responsible office, not the engine. */
+        rebuild_cadence: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        policy: "ephemeral" | "standing";
+        rebuild_cadence?: string | undefined;
+    }, {
+        policy?: "ephemeral" | "standing" | undefined;
+        rebuild_cadence?: string | undefined;
+    }>>;
+    /** The accountable office: an institutional chair id (the office, not its incumbent). One named
+     *  duty-holder answers for the room and for what it permits. */
+    responsible_chair: z.ZodOptional<z.ZodString>;
+    /** WHICH SUBSTRATE this room requires — a free string a deployment matches its available
+     *  realizers against (e.g. "container"). A FREE string, not a closed enum: the set of substrates
+     *  is a deployment fact rather than a genome one, and freezing it here would over-constrain
+     *  substrates the contract has not yet named. Absent means the deployment's default — deny-by-
+     *  default belongs on CAPABILITY, not on portability, so a room that names no substrate runs on
+     *  whatever is supplied, the same lean an unnamed venue takes on targeting. */
+    substrate: z.ZodOptional<z.ZodString>;
+    /** The MCP servers the room stands up. Each names credential CLASSES, never material — the same
+     *  discipline `credential_surface` takes, restated at the server that consumes them. */
+    mcp_servers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        slug: z.ZodString;
+        transport: z.ZodString;
+        command: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** The endpoint an over-the-wire transport (e.g. `sse`) connects to. Absent for a `stdio` server,
+         *  which is reached by its `command` instead — the per-transport requirement is stated once, in the
+         *  cross-field rule on `VenueSchema`, so both doors (the loader and venue_define) enforce it. */
+        url: z.ZodOptional<z.ZodString>;
+        credential_names: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        slug: string;
+        transport: string;
+        command: string[];
+        credential_names: string[];
+        url?: string | undefined;
+    }, {
+        slug: string;
+        transport: string;
+        url?: string | undefined;
+        command?: string[] | undefined;
+        credential_names?: string[] | undefined;
+    }>, "many">>;
+    /** The device CLASSES the room needs — a kind (`serial`, `gpio`…), never a path. The machine
+     *  maps a class to concrete nodes and the owning group; a contract that could name a node could
+     *  name the raw memory device, so the value is pinned to the closed enumeration. */
+    devices: z.ZodDefault<z.ZodArray<z.ZodEnum<["audio", "gpio", "i2c", "serial", "spi", "video"]>, "many">>;
+    /** The architectures this room supports (e.g. `arm64`). Absent means any: portability is not
+     *  capability, so an unnamed architecture is realizable on any host rather than none. */
+    architectures: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** A ceiling on how many chairs may realize against this room at once. Per-chair realization
+     *  multiplies substrate resources by the WIDTH of a phase, and memory scales with running
+     *  processes, so the bound belongs in the contract where an author sets it deliberately rather
+     *  than discovering it with the first wide DAG on the first box that runs it. */
+    max_concurrent_chairs: z.ZodOptional<z.ZodNumber>;
+    /** The shared FLOOR this room composes over, so N rooms cost floor + Σ(deltas) rather than
+     *  N × environment. A label two rooms share to declare they build on the same base. */
+    floor: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    slug: string;
+    institution_slug: string;
+    equipment: {
+        tools: string[];
+    };
+    installs: string[];
+    credential_surface: string[];
+    lifecycle: {
+        policy: "ephemeral" | "standing";
+        rebuild_cadence?: string | undefined;
+    };
+    mcp_servers: {
+        slug: string;
+        transport: string;
+        command: string[];
+        credential_names: string[];
+        url?: string | undefined;
+    }[];
+    devices: ("audio" | "gpio" | "i2c" | "serial" | "spi" | "video")[];
+    architectures: string[];
+    description?: string | undefined;
+    flavor?: string | undefined;
+    doors?: {
+        ingress: string[];
+        egress: string[];
+    } | undefined;
+    responsible_chair?: string | undefined;
+    substrate?: string | undefined;
+    max_concurrent_chairs?: number | undefined;
+    floor?: string | undefined;
+}, {
+    slug: string;
+    institution_slug: string;
+    description?: string | undefined;
+    flavor?: string | undefined;
+    equipment?: {
+        tools?: string[] | undefined;
+    } | undefined;
+    doors?: {
+        ingress?: string[] | undefined;
+        egress?: string[] | undefined;
+    } | undefined;
+    installs?: string[] | undefined;
+    credential_surface?: string[] | undefined;
+    lifecycle?: {
+        policy?: "ephemeral" | "standing" | undefined;
+        rebuild_cadence?: string | undefined;
+    } | undefined;
+    responsible_chair?: string | undefined;
+    substrate?: string | undefined;
+    mcp_servers?: {
+        slug: string;
+        transport: string;
+        url?: string | undefined;
+        command?: string[] | undefined;
+        credential_names?: string[] | undefined;
+    }[] | undefined;
+    devices?: ("audio" | "gpio" | "i2c" | "serial" | "spi" | "video")[] | undefined;
+    architectures?: string[] | undefined;
+    max_concurrent_chairs?: number | undefined;
+    floor?: string | undefined;
+}>;
+/**
+ * The venue contract, with the cross-field MCP rules a single field cannot state.
+ *
+ * The inner `VenueObjectSchema` above is a plain `ZodObject` — it retains `.shape`, which
+ * `zodToMcpProps(VenueObjectSchema)` (the advertised MCP surface) and `Object.keys(...shape)` (the
+ * hosted-write key list) both need. `VenueSchema` wraps it in a `.superRefine`, which is a
+ * `ZodEffects` that has NEITHER — so those two consumers read the inner object while every
+ * `.parse`/`.safeParse` caller (the loader, `venue_define`, the realizer) gets the cross-field rules
+ * for free. The three rules below are the ones a room could otherwise author "granted but
+ * unprovided": a tool naming a server the room never declared, a transport missing the field that
+ * makes it reachable, or a server needing a credential the surface does not admit. Each is refused at
+ * PARSE, moving the discovery from a box nobody is watching to the author's own terminal.
+ */
+export declare const VenueSchema: z.ZodEffects<z.ZodObject<{
     slug: z.ZodString;
     /** Exactly one owning institution. The institution is the duty holder; the office below is the
      *  appointed accountable individual. */
@@ -2321,6 +2568,52 @@ export declare const VenueSchema: z.ZodObject<{
     /** The accountable office: an institutional chair id (the office, not its incumbent). One named
      *  duty-holder answers for the room and for what it permits. */
     responsible_chair: z.ZodOptional<z.ZodString>;
+    /** WHICH SUBSTRATE this room requires — a free string a deployment matches its available
+     *  realizers against (e.g. "container"). A FREE string, not a closed enum: the set of substrates
+     *  is a deployment fact rather than a genome one, and freezing it here would over-constrain
+     *  substrates the contract has not yet named. Absent means the deployment's default — deny-by-
+     *  default belongs on CAPABILITY, not on portability, so a room that names no substrate runs on
+     *  whatever is supplied, the same lean an unnamed venue takes on targeting. */
+    substrate: z.ZodOptional<z.ZodString>;
+    /** The MCP servers the room stands up. Each names credential CLASSES, never material — the same
+     *  discipline `credential_surface` takes, restated at the server that consumes them. */
+    mcp_servers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        slug: z.ZodString;
+        transport: z.ZodString;
+        command: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** The endpoint an over-the-wire transport (e.g. `sse`) connects to. Absent for a `stdio` server,
+         *  which is reached by its `command` instead — the per-transport requirement is stated once, in the
+         *  cross-field rule on `VenueSchema`, so both doors (the loader and venue_define) enforce it. */
+        url: z.ZodOptional<z.ZodString>;
+        credential_names: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        slug: string;
+        transport: string;
+        command: string[];
+        credential_names: string[];
+        url?: string | undefined;
+    }, {
+        slug: string;
+        transport: string;
+        url?: string | undefined;
+        command?: string[] | undefined;
+        credential_names?: string[] | undefined;
+    }>, "many">>;
+    /** The device CLASSES the room needs — a kind (`serial`, `gpio`…), never a path. The machine
+     *  maps a class to concrete nodes and the owning group; a contract that could name a node could
+     *  name the raw memory device, so the value is pinned to the closed enumeration. */
+    devices: z.ZodDefault<z.ZodArray<z.ZodEnum<["audio", "gpio", "i2c", "serial", "spi", "video"]>, "many">>;
+    /** The architectures this room supports (e.g. `arm64`). Absent means any: portability is not
+     *  capability, so an unnamed architecture is realizable on any host rather than none. */
+    architectures: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** A ceiling on how many chairs may realize against this room at once. Per-chair realization
+     *  multiplies substrate resources by the WIDTH of a phase, and memory scales with running
+     *  processes, so the bound belongs in the contract where an author sets it deliberately rather
+     *  than discovering it with the first wide DAG on the first box that runs it. */
+    max_concurrent_chairs: z.ZodOptional<z.ZodNumber>;
+    /** The shared FLOOR this room composes over, so N rooms cost floor + Σ(deltas) rather than
+     *  N × environment. A label two rooms share to declare they build on the same base. */
+    floor: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
     slug: string;
     institution_slug: string;
@@ -2333,6 +2626,77 @@ export declare const VenueSchema: z.ZodObject<{
         policy: "ephemeral" | "standing";
         rebuild_cadence?: string | undefined;
     };
+    mcp_servers: {
+        slug: string;
+        transport: string;
+        command: string[];
+        credential_names: string[];
+        url?: string | undefined;
+    }[];
+    devices: ("audio" | "gpio" | "i2c" | "serial" | "spi" | "video")[];
+    architectures: string[];
+    description?: string | undefined;
+    flavor?: string | undefined;
+    doors?: {
+        ingress: string[];
+        egress: string[];
+    } | undefined;
+    responsible_chair?: string | undefined;
+    substrate?: string | undefined;
+    max_concurrent_chairs?: number | undefined;
+    floor?: string | undefined;
+}, {
+    slug: string;
+    institution_slug: string;
+    description?: string | undefined;
+    flavor?: string | undefined;
+    equipment?: {
+        tools?: string[] | undefined;
+    } | undefined;
+    doors?: {
+        ingress?: string[] | undefined;
+        egress?: string[] | undefined;
+    } | undefined;
+    installs?: string[] | undefined;
+    credential_surface?: string[] | undefined;
+    lifecycle?: {
+        policy?: "ephemeral" | "standing" | undefined;
+        rebuild_cadence?: string | undefined;
+    } | undefined;
+    responsible_chair?: string | undefined;
+    substrate?: string | undefined;
+    mcp_servers?: {
+        slug: string;
+        transport: string;
+        url?: string | undefined;
+        command?: string[] | undefined;
+        credential_names?: string[] | undefined;
+    }[] | undefined;
+    devices?: ("audio" | "gpio" | "i2c" | "serial" | "spi" | "video")[] | undefined;
+    architectures?: string[] | undefined;
+    max_concurrent_chairs?: number | undefined;
+    floor?: string | undefined;
+}>, {
+    slug: string;
+    institution_slug: string;
+    equipment: {
+        tools: string[];
+    };
+    installs: string[];
+    credential_surface: string[];
+    lifecycle: {
+        policy: "ephemeral" | "standing";
+        rebuild_cadence?: string | undefined;
+    };
+    mcp_servers: {
+        slug: string;
+        transport: string;
+        command: string[];
+        credential_names: string[];
+        url?: string | undefined;
+    }[];
+    devices: ("audio" | "gpio" | "i2c" | "serial" | "spi" | "video")[];
+    architectures: string[];
     description?: string | undefined;
     flavor?: string | undefined;
     doors?: {
@@ -2340,6 +2704,9 @@ export declare const VenueSchema: z.ZodObject<{
         egress: string[];
     } | undefined;
     responsible_chair?: string | undefined;
+    substrate?: string | undefined;
+    max_concurrent_chairs?: number | undefined;
+    floor?: string | undefined;
 }, {
     slug: string;
     institution_slug: string;
@@ -2359,17 +2726,31 @@ export declare const VenueSchema: z.ZodObject<{
         rebuild_cadence?: string | undefined;
     } | undefined;
     responsible_chair?: string | undefined;
+    substrate?: string | undefined;
+    mcp_servers?: {
+        slug: string;
+        transport: string;
+        url?: string | undefined;
+        command?: string[] | undefined;
+        credential_names?: string[] | undefined;
+    }[] | undefined;
+    devices?: ("audio" | "gpio" | "i2c" | "serial" | "spi" | "video")[] | undefined;
+    architectures?: string[] | undefined;
+    max_concurrent_chairs?: number | undefined;
+    floor?: string | undefined;
 }>;
 export type VenueInput = z.input<typeof VenueSchema>;
 export type VenueOutput = z.output<typeof VenueSchema>;
 /**
- * Cross-field venue rules — the ones a single field cannot state.
+ * The one cross-field venue rule that is NOT a parse error — the lifecycle snowflake below.
  *
- * A separate function rather than a `.superRefine`, on purpose and by the existing idiom
- * (`domainTypeDefect` in src/registry.ts): the MCP write-surface is generated from
- * `zodToMcpProps(VenueSchema)`, which needs a plain `ZodObject` with a `.shape`, and a refined
- * schema is a `ZodEffects` that has neither. So both doors — the loader and `venue_define` — call
- * `VenueSchema.safeParse` and then this, and a rule enforced at one door is enforced at both.
+ * The MCP cross-field rules (a granted server must be declared, a transport owes its reachability
+ * field, a credential must be in the surface) now live on `VenueSchema.superRefine`, so
+ * `VenueSchema.safeParse` catches them directly; the split into `VenueObjectSchema` (which keeps the
+ * `.shape` that `zodToMcpProps(VenueObjectSchema)` and `Object.keys(...shape)` need) is what let those
+ * rules move onto the schema without breaking the advertised surface. This function remains for the
+ * lifecycle rule, kept out of the schema so its teaching message stays a full paragraph rather than a
+ * ZodIssue string; both doors — the loader and `venue_define` — call `safeParse` and then this.
  *
  * Returns the teaching message, or null when the venue is sound.
  */