@eir-labs/coltrane 0.8.1 → 0.9.0

package/dist/src/genome_schema.d.ts

@@ -2377,4 +2377,506 @@ export declare function venueDefect(venue: VenueOutput): string | null;
 type JsonType = "string" | "number" | "boolean" | "array" | "object";
 /** The MCP `properties` map (field → JSON type) for a genome class schema. */
 export declare function zodToMcpProps(schema: z.ZodObject<z.ZodRawShape>): Record<string, JsonType>;
+/** How a Resource REFILLS, expressed in the resource's OWN unit — a monthly seat renews, a one-off
+ *  purchase does not, a rate-based capacity decays. `quantity` is a magnitude in the SAME unit the
+ *  Resource declares; `per_period` is the cadence it renews over (absent for a one-off). NOTHING
+ *  here converts between units — replenishment is a quantity-over-time in one unit, never a rate
+ *  table that would smuggle an exchange rate in. */
+export declare const ReplenishmentSchema: z.ZodObject<{
+    kind: z.ZodEnum<["renewing", "one_off", "rate_based"]>;
+    /** The magnitude that refills each period, in the Resource's OWN unit. Zero for a pure one-off. */
+    quantity: z.ZodNumber;
+    /** The cadence the quantity renews over (e.g. "monthly", "2026-Q3"). Absent for a one-off. */
+    per_period: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    kind: "renewing" | "one_off" | "rate_based";
+    quantity: number;
+    per_period?: string | undefined;
+}, {
+    kind: "renewing" | "one_off" | "rate_based";
+    quantity: number;
+    per_period?: string | undefined;
+}>;
+/** One draw against declared capacity — UNIT-TAGGED. A booking draws a VECTOR of these; over-commitment
+ *  is checked per unit with NO exchange rate anywhere. */
+export declare const DrawSchema: z.ZodObject<{
+    resource_slug: z.ZodString;
+    unit: z.ZodString;
+    quantity: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    quantity: number;
+    resource_slug: string;
+    unit: string;
+}, {
+    quantity: number;
+    resource_slug: string;
+    unit: string;
+}>;
+/** Capacity as its OWN class. A holding of some opaque, non-convertible `unit` by a `holder` (an
+ *  organization slug), for a `period`, transferable across organizations or not. `replenishment` is
+ *  OPTIONAL and describes how the holding refills IN ITS OWN UNIT — one Resource definition serves a
+ *  renewing, one-off, or rate-based holding without a parallel ledger that could disagree. */
+export declare const ResourceSchema: z.ZodObject<{
+    slug: z.ZodString;
+    holder: z.ZodString;
+    quantity: z.ZodNumber;
+    unit: z.ZodString;
+    /**
+     * REQUIRED, and it must stay required — this field is what makes a Resource a BUDGET rather
+     * than a running balance, and the difference is load-bearing.
+     *
+     * A Resource is "this much, over this window". Capacity is settled ONCE, at declaration, and
+     * held as a commitment for the window; anything continuous underneath it — a decaying holding,
+     * a replenishing one — determines the NEXT declaration rather than being read live inside this
+     * one. That is what a budget is, and it is consistent with a layer whose subject is committed
+     * work: a commitment is a stored fact even when it was computed from something continuous.
+     *
+     * WHAT BREAKS IF THIS GOES OPTIONAL. The tempting change is a one-off holding that "has no
+     * window" — it feels like it should not need one. But a quantity with no window is a running
+     * balance, and a running balance is continuously readable: ask `checkTourCapacity` enough
+     * times with varying draws and binary search recovers the holder's exact remaining capacity.
+     *
+     * For units whose magnitude is private — a pair's earned standing, an org's runway — that is an
+     * arbitrary-precision oracle reconstructed from an admissibility check that was never meant to
+     * answer it. The window is what stops it: within a period the answer is a fixed declared number
+     * the holder chose to commit, not a live reading of what they have.
+     *
+     * So a one-off holding still declares its window. It is not bureaucracy; it is the reason the
+     * check can be offered at all.
+     */
+    period: z.ZodString;
+    transferable: z.ZodBoolean;
+    replenishment: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<["renewing", "one_off", "rate_based"]>;
+        /** The magnitude that refills each period, in the Resource's OWN unit. Zero for a pure one-off. */
+        quantity: z.ZodNumber;
+        /** The cadence the quantity renews over (e.g. "monthly", "2026-Q3"). Absent for a one-off. */
+        per_period: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        kind: "renewing" | "one_off" | "rate_based";
+        quantity: number;
+        per_period?: string | undefined;
+    }, {
+        kind: "renewing" | "one_off" | "rate_based";
+        quantity: number;
+        per_period?: string | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    slug: string;
+    quantity: number;
+    unit: string;
+    holder: string;
+    period: string;
+    transferable: boolean;
+    replenishment?: {
+        kind: "renewing" | "one_off" | "rate_based";
+        quantity: number;
+        per_period?: string | undefined;
+    } | undefined;
+}, {
+    slug: string;
+    quantity: number;
+    unit: string;
+    holder: string;
+    period: string;
+    transferable: boolean;
+    replenishment?: {
+        kind: "renewing" | "one_off" | "rate_based";
+        quantity: number;
+        per_period?: string | undefined;
+    } | undefined;
+}>;
+/** One commitment in the binding middle place: the four load-bearing fields (aim, period,
+ *  accountable_office, acceptance) plus its draws, lifecycle and served north stars. `amount` is
+ *  OPTIONAL — a real commitment can have no price. `acceptance` and `antecedent` reuse the ONE
+ *  predicate form; `tier` reuses NormPairSchema's enum. */
+export declare const BookingSchema: z.ZodObject<{
+    slug: z.ZodString;
+    aim: z.ZodString;
+    amount: z.ZodOptional<z.ZodNumber>;
+    period: z.ZodString;
+    accountable_office: z.ZodString;
+    acceptance: z.ZodObject<{
+        /** A normalized, serializable predicate (e.g. an s-expression) an evaluator invokes. */
+        predicate: z.ZodString;
+        /** The typed inputs the predicate reads: input name → its type name. */
+        inputs: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        predicate: string;
+        inputs: Record<string, string>;
+    }, {
+        predicate: string;
+        inputs: Record<string, string>;
+    }>;
+    draws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        resource_slug: z.ZodString;
+        unit: z.ZodString;
+        quantity: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        quantity: number;
+        resource_slug: string;
+        unit: string;
+    }, {
+        quantity: number;
+        resource_slug: string;
+        unit: string;
+    }>, "many">>;
+    served_northstars: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    tier: z.ZodOptional<z.ZodEnum<["declared", "enforced"]>>;
+    lifecycle: z.ZodObject<{
+        state: z.ZodEnum<["conditional", "active", "pending", "satisfied", "violated", "expired", "cancelled", "released"]>;
+        debtor: z.ZodString;
+        creditor: z.ZodString;
+        log: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            op: z.ZodEnum<["create", "detach", "discharge", "cancel", "release", "delegate", "assign"]>;
+            by: z.ZodOptional<z.ZodEnum<["debtor", "creditor"]>>;
+            residual_debtor: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            op: "create" | "detach" | "discharge" | "cancel" | "release" | "delegate" | "assign";
+            by?: "debtor" | "creditor" | undefined;
+            residual_debtor?: string | undefined;
+        }, {
+            op: "create" | "detach" | "discharge" | "cancel" | "release" | "delegate" | "assign";
+            by?: "debtor" | "creditor" | undefined;
+            residual_debtor?: string | undefined;
+        }>, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        debtor: string;
+        creditor: string;
+        state: "active" | "conditional" | "pending" | "satisfied" | "violated" | "expired" | "cancelled" | "released";
+        log: {
+            op: "create" | "detach" | "discharge" | "cancel" | "release" | "delegate" | "assign";
+            by?: "debtor" | "creditor" | undefined;
+            residual_debtor?: string | undefined;
+        }[];
+    }, {
+        debtor: string;
+        creditor: string;
+        state: "active" | "conditional" | "pending" | "satisfied" | "violated" | "expired" | "cancelled" | "released";
+        log?: {
+            op: "create" | "detach" | "discharge" | "cancel" | "release" | "delegate" | "assign";
+            by?: "debtor" | "creditor" | undefined;
+            residual_debtor?: string | undefined;
+        }[] | undefined;
+    }>;
+    settled_gig_ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    antecedent: z.ZodOptional<z.ZodObject<{
+        /** A normalized, serializable predicate (e.g. an s-expression) an evaluator invokes. */
+        predicate: z.ZodString;
+        /** The typed inputs the predicate reads: input name → its type name. */
+        inputs: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        predicate: string;
+        inputs: Record<string, string>;
+    }, {
+        predicate: string;
+        inputs: Record<string, string>;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    slug: string;
+    aim: string;
+    lifecycle: {
+        debtor: string;
+        creditor: string;
+        state: "active" | "conditional" | "pending" | "satisfied" | "violated" | "expired" | "cancelled" | "released";
+        log: {
+            op: "create" | "detach" | "discharge" | "cancel" | "release" | "delegate" | "assign";
+            by?: "debtor" | "creditor" | undefined;
+            residual_debtor?: string | undefined;
+        }[];
+    };
+    period: string;
+    accountable_office: string;
+    acceptance: {
+        predicate: string;
+        inputs: Record<string, string>;
+    };
+    draws: {
+        quantity: number;
+        resource_slug: string;
+        unit: string;
+    }[];
+    served_northstars: string[];
+    tier?: "declared" | "enforced" | undefined;
+    amount?: number | undefined;
+    settled_gig_ids?: string[] | undefined;
+    antecedent?: {
+        predicate: string;
+        inputs: Record<string, string>;
+    } | undefined;
+}, {
+    slug: string;
+    aim: string;
+    lifecycle: {
+        debtor: string;
+        creditor: string;
+        state: "active" | "conditional" | "pending" | "satisfied" | "violated" | "expired" | "cancelled" | "released";
+        log?: {
+            op: "create" | "detach" | "discharge" | "cancel" | "release" | "delegate" | "assign";
+            by?: "debtor" | "creditor" | undefined;
+            residual_debtor?: string | undefined;
+        }[] | undefined;
+    };
+    period: string;
+    accountable_office: string;
+    acceptance: {
+        predicate: string;
+        inputs: Record<string, string>;
+    };
+    tier?: "declared" | "enforced" | undefined;
+    amount?: number | undefined;
+    draws?: {
+        quantity: number;
+        resource_slug: string;
+        unit: string;
+    }[] | undefined;
+    served_northstars?: string[] | undefined;
+    settled_gig_ids?: string[] | undefined;
+    antecedent?: {
+        predicate: string;
+        inputs: Record<string, string>;
+    } | undefined;
+}>;
+/** The institution-visible aggregation — it REFERENCES an institution (the constraint) and an
+ *  organization (the accountable player) by slug; it does NOT live inside InstitutionSchema. */
+export declare const TourSchema: z.ZodObject<{
+    slug: z.ZodString;
+    institution_slug: z.ZodString;
+    org_slug: z.ZodString;
+    responsible_chair: z.ZodString;
+    period: z.ZodString;
+    northstar_slugs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    bookings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        slug: z.ZodString;
+        aim: z.ZodString;
+        amount: z.ZodOptional<z.ZodNumber>;
+        period: z.ZodString;
+        accountable_office: z.ZodString;
+        acceptance: z.ZodObject<{
+            /** A normalized, serializable predicate (e.g. an s-expression) an evaluator invokes. */
+            predicate: z.ZodString;
+            /** The typed inputs the predicate reads: input name → its type name. */
+            inputs: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            predicate: string;
+            inputs: Record<string, string>;
+        }, {
+            predicate: string;
+            inputs: Record<string, string>;
+        }>;
+        draws: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            resource_slug: z.ZodString;
+            unit: z.ZodString;
+            quantity: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            quantity: number;
+            resource_slug: string;
+            unit: string;
+        }, {
+            quantity: number;
+            resource_slug: string;
+            unit: string;
+        }>, "many">>;
+        served_northstars: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        tier: z.ZodOptional<z.ZodEnum<["declared", "enforced"]>>;
+        lifecycle: z.ZodObject<{
+            state: z.ZodEnum<["conditional", "active", "pending", "satisfied", "violated", "expired", "cancelled", "released"]>;
+            debtor: z.ZodString;
+            creditor: z.ZodString;
+            log: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                op: z.ZodEnum<["create", "detach", "discharge", "cancel", "release", "delegate", "assign"]>;
+                by: z.ZodOptional<z.ZodEnum<["debtor", "creditor"]>>;
+                residual_debtor: z.ZodOptional<z.ZodString>;
+            }, "strict", z.ZodTypeAny, {
+                op: "create" | "detach" | "discharge" | "cancel" | "release" | "delegate" | "assign";
+                by?: "debtor" | "creditor" | undefined;
+                residual_debtor?: string | undefined;
+            }, {
+                op: "create" | "detach" | "discharge" | "cancel" | "release" | "delegate" | "assign";
+                by?: "debtor" | "creditor" | undefined;
+                residual_debtor?: string | undefined;
+            }>, "many">>;
+        }, "strict", z.ZodTypeAny, {
+            debtor: string;
+            creditor: string;
+            state: "active" | "conditional" | "pending" | "satisfied" | "violated" | "expired" | "cancelled" | "released";
+            log: {
+                op: "create" | "detach" | "discharge" | "cancel" | "release" | "delegate" | "assign";
+                by?: "debtor" | "creditor" | undefined;
+                residual_debtor?: string | undefined;
+            }[];
+        }, {
+            debtor: string;
+            creditor: string;
+            state: "active" | "conditional" | "pending" | "satisfied" | "violated" | "expired" | "cancelled" | "released";
+            log?: {
+                op: "create" | "detach" | "discharge" | "cancel" | "release" | "delegate" | "assign";
+                by?: "debtor" | "creditor" | undefined;
+                residual_debtor?: string | undefined;
+            }[] | undefined;
+        }>;
+        settled_gig_ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        antecedent: z.ZodOptional<z.ZodObject<{
+            /** A normalized, serializable predicate (e.g. an s-expression) an evaluator invokes. */
+            predicate: z.ZodString;
+            /** The typed inputs the predicate reads: input name → its type name. */
+            inputs: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            predicate: string;
+            inputs: Record<string, string>;
+        }, {
+            predicate: string;
+            inputs: Record<string, string>;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        slug: string;
+        aim: string;
+        lifecycle: {
+            debtor: string;
+            creditor: string;
+            state: "active" | "conditional" | "pending" | "satisfied" | "violated" | "expired" | "cancelled" | "released";
+            log: {
+                op: "create" | "detach" | "discharge" | "cancel" | "release" | "delegate" | "assign";
+                by?: "debtor" | "creditor" | undefined;
+                residual_debtor?: string | undefined;
+            }[];
+        };
+        period: string;
+        accountable_office: string;
+        acceptance: {
+            predicate: string;
+            inputs: Record<string, string>;
+        };
+        draws: {
+            quantity: number;
+            resource_slug: string;
+            unit: string;
+        }[];
+        served_northstars: string[];
+        tier?: "declared" | "enforced" | undefined;
+        amount?: number | undefined;
+        settled_gig_ids?: string[] | undefined;
+        antecedent?: {
+            predicate: string;
+            inputs: Record<string, string>;
+        } | undefined;
+    }, {
+        slug: string;
+        aim: string;
+        lifecycle: {
+            debtor: string;
+            creditor: string;
+            state: "active" | "conditional" | "pending" | "satisfied" | "violated" | "expired" | "cancelled" | "released";
+            log?: {
+                op: "create" | "detach" | "discharge" | "cancel" | "release" | "delegate" | "assign";
+                by?: "debtor" | "creditor" | undefined;
+                residual_debtor?: string | undefined;
+            }[] | undefined;
+        };
+        period: string;
+        accountable_office: string;
+        acceptance: {
+            predicate: string;
+            inputs: Record<string, string>;
+        };
+        tier?: "declared" | "enforced" | undefined;
+        amount?: number | undefined;
+        draws?: {
+            quantity: number;
+            resource_slug: string;
+            unit: string;
+        }[] | undefined;
+        served_northstars?: string[] | undefined;
+        settled_gig_ids?: string[] | undefined;
+        antecedent?: {
+            predicate: string;
+            inputs: Record<string, string>;
+        } | undefined;
+    }>, "many">>;
+}, "strict", z.ZodTypeAny, {
+    slug: string;
+    org_slug: string;
+    institution_slug: string;
+    responsible_chair: string;
+    period: string;
+    northstar_slugs: string[];
+    bookings: {
+        slug: string;
+        aim: string;
+        lifecycle: {
+            debtor: string;
+            creditor: string;
+            state: "active" | "conditional" | "pending" | "satisfied" | "violated" | "expired" | "cancelled" | "released";
+            log: {
+                op: "create" | "detach" | "discharge" | "cancel" | "release" | "delegate" | "assign";
+                by?: "debtor" | "creditor" | undefined;
+                residual_debtor?: string | undefined;
+            }[];
+        };
+        period: string;
+        accountable_office: string;
+        acceptance: {
+            predicate: string;
+            inputs: Record<string, string>;
+        };
+        draws: {
+            quantity: number;
+            resource_slug: string;
+            unit: string;
+        }[];
+        served_northstars: string[];
+        tier?: "declared" | "enforced" | undefined;
+        amount?: number | undefined;
+        settled_gig_ids?: string[] | undefined;
+        antecedent?: {
+            predicate: string;
+            inputs: Record<string, string>;
+        } | undefined;
+    }[];
+}, {
+    slug: string;
+    org_slug: string;
+    institution_slug: string;
+    responsible_chair: string;
+    period: string;
+    northstar_slugs?: string[] | undefined;
+    bookings?: {
+        slug: string;
+        aim: string;
+        lifecycle: {
+            debtor: string;
+            creditor: string;
+            state: "active" | "conditional" | "pending" | "satisfied" | "violated" | "expired" | "cancelled" | "released";
+            log?: {
+                op: "create" | "detach" | "discharge" | "cancel" | "release" | "delegate" | "assign";
+                by?: "debtor" | "creditor" | undefined;
+                residual_debtor?: string | undefined;
+            }[] | undefined;
+        };
+        period: string;
+        accountable_office: string;
+        acceptance: {
+            predicate: string;
+            inputs: Record<string, string>;
+        };
+        tier?: "declared" | "enforced" | undefined;
+        amount?: number | undefined;
+        draws?: {
+            quantity: number;
+            resource_slug: string;
+            unit: string;
+        }[] | undefined;
+        served_northstars?: string[] | undefined;
+        settled_gig_ids?: string[] | undefined;
+        antecedent?: {
+            predicate: string;
+            inputs: Record<string, string>;
+        } | undefined;
+    }[] | undefined;
+}>;
+export type ReplenishmentOutput = z.output<typeof ReplenishmentSchema>;
+export type DrawOutput = z.output<typeof DrawSchema>;
+export type ResourceOutput = z.output<typeof ResourceSchema>;
+export type BookingOutput = z.output<typeof BookingSchema>;
+export type TourOutput = z.output<typeof TourSchema>;
 export {};