loopgraph 0.1.0

package/dist/schema/model.d.ts

@@ -0,0 +1,661 @@
+import { z } from "zod";
+/**
+ * IDs are re-used verbatim from the source research documents so that the
+ * drift test (test/drift.test.ts) can diff model IDs against IDs extracted
+ * straight out of the PR tables, with no hand-maintained translation layer.
+ */
+export declare const LoopId: z.ZodString;
+export type LoopId = z.infer<typeof LoopId>;
+export declare const FlowId: z.ZodString;
+export type FlowId = z.infer<typeof FlowId>;
+export declare const FeatureId: z.ZodString;
+export type FeatureId = z.infer<typeof FeatureId>;
+export declare const JunctionId: z.ZodString;
+export type JunctionId = z.infer<typeof JunctionId>;
+export declare const ScenarioId: z.ZodString;
+export type ScenarioId = z.infer<typeof ScenarioId>;
+/**
+ * Max length of `Evidence.note`. `note` exists only to help a reader
+ * *locate* the anchored evidence (a line range, a function name, a test-name
+ * fragment) — NOT to narrate causal reasoning or historical background.
+ * The cap is a mechanical backstop for that intent: prose explanations run
+ * long, pointers stay short. Kept as a named const so the schema test and
+ * any future review tooling reference the same number.
+ */
+export declare const EVIDENCE_NOTE_MAX = 200;
+/**
+ * Evidence is embedded inside Junction (evidence: Evidence[]) rather than
+ * a standalone top-level file — it only makes sense bound to the claim it
+ * proves. Scenario does NOT carry Evidence directly: its `verified_by`
+ * field holds plain test/E2E anchor strings instead, since GWT→test
+ * binding is a simpler 1:many mapping than Junction's need for typed,
+ * multi-kind evidence.
+ *
+ * `kind` taxonomy:
+ * - Runtime/code evidence: test / durable_event / e2e / metric / trace /
+ *   log / code — an anchor that resolves to a projection or observation of
+ *   the running system.
+ * - Intent/planning evidence (Proposal 006 A1): `spec` points at a
+ *   requirement/design statement (a spec section, an ADR line), `issue`
+ *   points at a tracked work item (a GitHub issue/PR reference). These let
+ *   a junction cite "this handoff is deliberately deferred, see #NNNN" or
+ *   "the poller's settled≠done semantics is specified here" without dressing
+ *   a planning pointer up as a runtime observation. Because they are the
+ *   easiest kind to smuggle prose into, `note` on these is held to the same
+ *   anchor-only, pointer-not-narrative discipline as every other kind (see
+ *   `EVIDENCE_NOTE_MAX`); reviewers of any content PR treat a `spec`/`issue`
+ *   note that argues causation or recounts history as a defect.
+ */
+export declare const Evidence: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<["test", "durable_event", "e2e", "metric", "trace", "log", "code", "spec", "issue"]>;
+    anchor: z.ZodString;
+    source: z.ZodOptional<z.ZodString>;
+    transport: z.ZodOptional<z.ZodEnum<["direct", "relay", "durable_event"]>>;
+    binding: z.ZodOptional<z.ZodObject<{
+        image_revision: z.ZodEnum<["required", "optional"]>;
+    }, "strip", z.ZodTypeAny, {
+        image_revision: "required" | "optional";
+    }, {
+        image_revision: "required" | "optional";
+    }>>;
+    confidence: z.ZodOptional<z.ZodEnum<["high", "medium", "low"]>>;
+    note: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    anchor: string;
+    id: string;
+    kind: "code" | "test" | "durable_event" | "e2e" | "metric" | "trace" | "log" | "spec" | "issue";
+    source?: string | undefined;
+    transport?: "durable_event" | "direct" | "relay" | undefined;
+    binding?: {
+        image_revision: "required" | "optional";
+    } | undefined;
+    confidence?: "high" | "medium" | "low" | undefined;
+    note?: string | undefined;
+}, {
+    anchor: string;
+    id: string;
+    kind: "code" | "test" | "durable_event" | "e2e" | "metric" | "trace" | "log" | "spec" | "issue";
+    source?: string | undefined;
+    transport?: "durable_event" | "direct" | "relay" | undefined;
+    binding?: {
+        image_revision: "required" | "optional";
+    } | undefined;
+    confidence?: "high" | "medium" | "low" | undefined;
+    note?: string | undefined;
+}>;
+export type Evidence = z.infer<typeof Evidence>;
+/**
+ * Loop covers both ordinary top-level loops (L1, N19, ...) and the
+ * "(内嵌)" embedded submachines (L1a/L1b/L3a/L20a) that share a parent's
+ * boundary but carry their own state. Dormant/unwired loops like N8
+ * ("M2 休眠") have owner: null and dormant: true instead of being dropped.
+ */
+export declare const Loop: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"loop">;
+    title: z.ZodString;
+    boundary: z.ZodString;
+    owner: z.ZodNullable<z.ZodString>;
+    section: z.ZodOptional<z.ZodString>;
+    parent: z.ZodOptional<z.ZodString>;
+    embedded: z.ZodOptional<z.ZodBoolean>;
+    dormant: z.ZodOptional<z.ZodBoolean>;
+    status: z.ZodDefault<z.ZodEnum<["conformant", "unimplemented", "unverified", "drifted", "unregistered", "deprecated"]>>;
+    anchors: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * pg-boss queue names this loop CONSUMES (Proposal 006 C2 root-fix). A queue is
+     * defined at its producer/enqueue site (e.g. a shared `services.ts` registry)
+     * but its lifecycle belongs to the consuming loop, which may live in a
+     * different file. Declaring the names here lets reconciliation register a queue
+     * fact by NAME — so a producer-registry definition is not a false "unregistered"
+     * just because its file carries no anchor. This is an explicit modeling
+     * assertion ("this loop consumes order:process"), verified against the
+     * consumer's queue handler; it is NOT a way to silence facts (that would be a
+     * dormant loop) and NOT a synthetic node (a registry file is not a loop).
+     */
+    consumes_queues: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    scenarios: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    notes: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    status: "conformant" | "unimplemented" | "unverified" | "drifted" | "unregistered" | "deprecated";
+    id: string;
+    kind: "loop";
+    title: string;
+    boundary: string;
+    owner: string | null;
+    anchors: string[];
+    consumes_queues: string[];
+    scenarios: string[];
+    section?: string | undefined;
+    parent?: string | undefined;
+    embedded?: boolean | undefined;
+    dormant?: boolean | undefined;
+    notes?: string | undefined;
+}, {
+    id: string;
+    kind: "loop";
+    title: string;
+    boundary: string;
+    owner: string | null;
+    status?: "conformant" | "unimplemented" | "unverified" | "drifted" | "unregistered" | "deprecated" | undefined;
+    section?: string | undefined;
+    parent?: string | undefined;
+    embedded?: boolean | undefined;
+    dormant?: boolean | undefined;
+    anchors?: string[] | undefined;
+    consumes_queues?: string[] | undefined;
+    scenarios?: string[] | undefined;
+    notes?: string | undefined;
+}>;
+export type Loop = z.infer<typeof Loop>;
+/**
+ * Flow = composite flow (C1..C9). `traverses` is the ordered loop sequence;
+ * `guarded_by` holds watchdog loops (e.g. C1's L9) that don't sit in the
+ * primary sequence but cover it; `references` holds sub-flow composition
+ * (e.g. C1 references C2/C3 as expandable sub-chains).
+ */
+export declare const Flow: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"flow">;
+    title: z.ZodString;
+    traverses: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    guarded_by: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    crosses: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    references: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    risk_notes: z.ZodOptional<z.ZodString>;
+    status: z.ZodDefault<z.ZodEnum<["conformant", "unimplemented", "unverified", "drifted", "unregistered", "deprecated"]>>;
+}, "strip", z.ZodTypeAny, {
+    status: "conformant" | "unimplemented" | "unverified" | "drifted" | "unregistered" | "deprecated";
+    id: string;
+    kind: "flow";
+    title: string;
+    traverses: string[];
+    guarded_by: string[];
+    crosses: string[];
+    references: string[];
+    risk_notes?: string | undefined;
+}, {
+    id: string;
+    kind: "flow";
+    title: string;
+    status?: "conformant" | "unimplemented" | "unverified" | "drifted" | "unregistered" | "deprecated" | undefined;
+    traverses?: string[] | undefined;
+    guarded_by?: string[] | undefined;
+    crosses?: string[] | undefined;
+    references?: string[] | undefined;
+    risk_notes?: string | undefined;
+}>;
+export type Flow = z.infer<typeof Flow>;
+export declare const Junction: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"junction">;
+    title: z.ZodOptional<z.ZodString>;
+    risk_class: z.ZodEnum<["handoff", "idempotency", "projection", "failure_propagation", "watchdog"]>;
+    between: z.ZodArray<z.ZodString, "many">;
+    scenarios: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<["test", "durable_event", "e2e", "metric", "trace", "log", "code", "spec", "issue"]>;
+        anchor: z.ZodString;
+        source: z.ZodOptional<z.ZodString>;
+        transport: z.ZodOptional<z.ZodEnum<["direct", "relay", "durable_event"]>>;
+        binding: z.ZodOptional<z.ZodObject<{
+            image_revision: z.ZodEnum<["required", "optional"]>;
+        }, "strip", z.ZodTypeAny, {
+            image_revision: "required" | "optional";
+        }, {
+            image_revision: "required" | "optional";
+        }>>;
+        confidence: z.ZodOptional<z.ZodEnum<["high", "medium", "low"]>>;
+        note: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        anchor: string;
+        id: string;
+        kind: "code" | "test" | "durable_event" | "e2e" | "metric" | "trace" | "log" | "spec" | "issue";
+        source?: string | undefined;
+        transport?: "durable_event" | "direct" | "relay" | undefined;
+        binding?: {
+            image_revision: "required" | "optional";
+        } | undefined;
+        confidence?: "high" | "medium" | "low" | undefined;
+        note?: string | undefined;
+    }, {
+        anchor: string;
+        id: string;
+        kind: "code" | "test" | "durable_event" | "e2e" | "metric" | "trace" | "log" | "spec" | "issue";
+        source?: string | undefined;
+        transport?: "durable_event" | "direct" | "relay" | undefined;
+        binding?: {
+            image_revision: "required" | "optional";
+        } | undefined;
+        confidence?: "high" | "medium" | "low" | undefined;
+        note?: string | undefined;
+    }>, "many">>;
+    status: z.ZodDefault<z.ZodEnum<["conformant", "unimplemented", "unverified", "drifted", "unregistered", "deprecated"]>>;
+}, "strip", z.ZodTypeAny, {
+    status: "conformant" | "unimplemented" | "unverified" | "drifted" | "unregistered" | "deprecated";
+    id: string;
+    kind: "junction";
+    scenarios: string[];
+    risk_class: "handoff" | "idempotency" | "projection" | "failure_propagation" | "watchdog";
+    between: string[];
+    evidence: {
+        anchor: string;
+        id: string;
+        kind: "code" | "test" | "durable_event" | "e2e" | "metric" | "trace" | "log" | "spec" | "issue";
+        source?: string | undefined;
+        transport?: "durable_event" | "direct" | "relay" | undefined;
+        binding?: {
+            image_revision: "required" | "optional";
+        } | undefined;
+        confidence?: "high" | "medium" | "low" | undefined;
+        note?: string | undefined;
+    }[];
+    title?: string | undefined;
+}, {
+    id: string;
+    kind: "junction";
+    risk_class: "handoff" | "idempotency" | "projection" | "failure_propagation" | "watchdog";
+    between: string[];
+    status?: "conformant" | "unimplemented" | "unverified" | "drifted" | "unregistered" | "deprecated" | undefined;
+    title?: string | undefined;
+    scenarios?: string[] | undefined;
+    evidence?: {
+        anchor: string;
+        id: string;
+        kind: "code" | "test" | "durable_event" | "e2e" | "metric" | "trace" | "log" | "spec" | "issue";
+        source?: string | undefined;
+        transport?: "durable_event" | "direct" | "relay" | undefined;
+        binding?: {
+            image_revision: "required" | "optional";
+        } | undefined;
+        confidence?: "high" | "medium" | "low" | undefined;
+        note?: string | undefined;
+    }[] | undefined;
+}>;
+export type Junction = z.infer<typeof Junction>;
+/**
+ * Selector for effective-constraints propagation (Decision record 004,
+ * 技术点 2): decides which nodes an Invariant-flavored Scenario applies
+ * to automatically, without hand-listing the scenario id in every
+ * relevant node's `scenarios` array. Resolved at query time by
+ * src/query/effective-constraints.ts, never materialized — see that
+ * module for match semantics (owner_match is substring containment with
+ * optional `*` wildcard, NOT prefix-anchored or POSIX glob).
+ */
+export declare const AppliesTo: z.ZodObject<{
+    nodes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    owner_match: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    nodes: string[];
+    owner_match?: string | undefined;
+}, {
+    nodes?: string[] | undefined;
+    owner_match?: string | undefined;
+}>;
+export type AppliesTo = z.infer<typeof AppliesTo>;
+export declare const Scenario: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"scenario">;
+    given: z.ZodString;
+    when: z.ZodString;
+    then: z.ZodString;
+    level: z.ZodEnum<["unit", "focused-integration", "contract", "integration", "e2e", "operational"]>;
+    verified_by: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    applies_to: z.ZodOptional<z.ZodObject<{
+        nodes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        owner_match: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        nodes: string[];
+        owner_match?: string | undefined;
+    }, {
+        nodes?: string[] | undefined;
+        owner_match?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    then: string;
+    id: string;
+    kind: "scenario";
+    given: string;
+    when: string;
+    level: "e2e" | "unit" | "focused-integration" | "contract" | "integration" | "operational";
+    verified_by: string[];
+    applies_to?: {
+        nodes: string[];
+        owner_match?: string | undefined;
+    } | undefined;
+}, {
+    then: string;
+    id: string;
+    kind: "scenario";
+    given: string;
+    when: string;
+    level: "e2e" | "unit" | "focused-integration" | "contract" | "integration" | "operational";
+    verified_by?: string[] | undefined;
+    applies_to?: {
+        nodes?: string[] | undefined;
+        owner_match?: string | undefined;
+    } | undefined;
+}>;
+export type Scenario = z.infer<typeof Scenario>;
+export declare const Feature: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"feature">;
+    title: z.ZodString;
+    contains: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    status: z.ZodDefault<z.ZodEnum<["conformant", "unimplemented", "unverified", "drifted", "unregistered", "deprecated"]>>;
+}, "strip", z.ZodTypeAny, {
+    status: "conformant" | "unimplemented" | "unverified" | "drifted" | "unregistered" | "deprecated";
+    id: string;
+    kind: "feature";
+    title: string;
+    contains: string[];
+}, {
+    id: string;
+    kind: "feature";
+    title: string;
+    status?: "conformant" | "unimplemented" | "unverified" | "drifted" | "unregistered" | "deprecated" | undefined;
+    contains?: string[] | undefined;
+}>;
+export type Feature = z.infer<typeof Feature>;
+/**
+ * DebtEntry is deliberately a different shape from Loop: the 6
+ * dead-state-machine tables and 2 deferred loops from the seed baseline describe
+ * something that LOOKS like a loop (has a status column / was scoped as
+ * a loop) but fails the "independent advance mechanism" test — they are
+ * baseline debt, not behavior to model as Loop nodes.
+ */
+export declare const DebtId: z.ZodString;
+export type DebtId = z.infer<typeof DebtId>;
+export declare const DebtEntry: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"debt">;
+    category: z.ZodEnum<["dead_state_machine", "deferred", "other"]>;
+    subject: z.ZodString;
+    claim: z.ZodOptional<z.ZodString>;
+    reality: z.ZodString;
+    owner: z.ZodOptional<z.ZodString>;
+    removal_condition: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    kind: "debt";
+    category: "dead_state_machine" | "deferred" | "other";
+    subject: string;
+    reality: string;
+    owner?: string | undefined;
+    claim?: string | undefined;
+    removal_condition?: string | undefined;
+}, {
+    id: string;
+    kind: "debt";
+    category: "dead_state_machine" | "deferred" | "other";
+    subject: string;
+    reality: string;
+    owner?: string | undefined;
+    claim?: string | undefined;
+    removal_condition?: string | undefined;
+}>;
+export type DebtEntry = z.infer<typeof DebtEntry>;
+export declare const ModelNode: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"feature">;
+    title: z.ZodString;
+    contains: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    status: z.ZodDefault<z.ZodEnum<["conformant", "unimplemented", "unverified", "drifted", "unregistered", "deprecated"]>>;
+}, "strip", z.ZodTypeAny, {
+    status: "conformant" | "unimplemented" | "unverified" | "drifted" | "unregistered" | "deprecated";
+    id: string;
+    kind: "feature";
+    title: string;
+    contains: string[];
+}, {
+    id: string;
+    kind: "feature";
+    title: string;
+    status?: "conformant" | "unimplemented" | "unverified" | "drifted" | "unregistered" | "deprecated" | undefined;
+    contains?: string[] | undefined;
+}>, z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"flow">;
+    title: z.ZodString;
+    traverses: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    guarded_by: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    crosses: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    references: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    risk_notes: z.ZodOptional<z.ZodString>;
+    status: z.ZodDefault<z.ZodEnum<["conformant", "unimplemented", "unverified", "drifted", "unregistered", "deprecated"]>>;
+}, "strip", z.ZodTypeAny, {
+    status: "conformant" | "unimplemented" | "unverified" | "drifted" | "unregistered" | "deprecated";
+    id: string;
+    kind: "flow";
+    title: string;
+    traverses: string[];
+    guarded_by: string[];
+    crosses: string[];
+    references: string[];
+    risk_notes?: string | undefined;
+}, {
+    id: string;
+    kind: "flow";
+    title: string;
+    status?: "conformant" | "unimplemented" | "unverified" | "drifted" | "unregistered" | "deprecated" | undefined;
+    traverses?: string[] | undefined;
+    guarded_by?: string[] | undefined;
+    crosses?: string[] | undefined;
+    references?: string[] | undefined;
+    risk_notes?: string | undefined;
+}>, z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"loop">;
+    title: z.ZodString;
+    boundary: z.ZodString;
+    owner: z.ZodNullable<z.ZodString>;
+    section: z.ZodOptional<z.ZodString>;
+    parent: z.ZodOptional<z.ZodString>;
+    embedded: z.ZodOptional<z.ZodBoolean>;
+    dormant: z.ZodOptional<z.ZodBoolean>;
+    status: z.ZodDefault<z.ZodEnum<["conformant", "unimplemented", "unverified", "drifted", "unregistered", "deprecated"]>>;
+    anchors: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * pg-boss queue names this loop CONSUMES (Proposal 006 C2 root-fix). A queue is
+     * defined at its producer/enqueue site (e.g. a shared `services.ts` registry)
+     * but its lifecycle belongs to the consuming loop, which may live in a
+     * different file. Declaring the names here lets reconciliation register a queue
+     * fact by NAME — so a producer-registry definition is not a false "unregistered"
+     * just because its file carries no anchor. This is an explicit modeling
+     * assertion ("this loop consumes order:process"), verified against the
+     * consumer's queue handler; it is NOT a way to silence facts (that would be a
+     * dormant loop) and NOT a synthetic node (a registry file is not a loop).
+     */
+    consumes_queues: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    scenarios: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    notes: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    status: "conformant" | "unimplemented" | "unverified" | "drifted" | "unregistered" | "deprecated";
+    id: string;
+    kind: "loop";
+    title: string;
+    boundary: string;
+    owner: string | null;
+    anchors: string[];
+    consumes_queues: string[];
+    scenarios: string[];
+    section?: string | undefined;
+    parent?: string | undefined;
+    embedded?: boolean | undefined;
+    dormant?: boolean | undefined;
+    notes?: string | undefined;
+}, {
+    id: string;
+    kind: "loop";
+    title: string;
+    boundary: string;
+    owner: string | null;
+    status?: "conformant" | "unimplemented" | "unverified" | "drifted" | "unregistered" | "deprecated" | undefined;
+    section?: string | undefined;
+    parent?: string | undefined;
+    embedded?: boolean | undefined;
+    dormant?: boolean | undefined;
+    anchors?: string[] | undefined;
+    consumes_queues?: string[] | undefined;
+    scenarios?: string[] | undefined;
+    notes?: string | undefined;
+}>, z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"junction">;
+    title: z.ZodOptional<z.ZodString>;
+    risk_class: z.ZodEnum<["handoff", "idempotency", "projection", "failure_propagation", "watchdog"]>;
+    between: z.ZodArray<z.ZodString, "many">;
+    scenarios: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<["test", "durable_event", "e2e", "metric", "trace", "log", "code", "spec", "issue"]>;
+        anchor: z.ZodString;
+        source: z.ZodOptional<z.ZodString>;
+        transport: z.ZodOptional<z.ZodEnum<["direct", "relay", "durable_event"]>>;
+        binding: z.ZodOptional<z.ZodObject<{
+            image_revision: z.ZodEnum<["required", "optional"]>;
+        }, "strip", z.ZodTypeAny, {
+            image_revision: "required" | "optional";
+        }, {
+            image_revision: "required" | "optional";
+        }>>;
+        confidence: z.ZodOptional<z.ZodEnum<["high", "medium", "low"]>>;
+        note: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        anchor: string;
+        id: string;
+        kind: "code" | "test" | "durable_event" | "e2e" | "metric" | "trace" | "log" | "spec" | "issue";
+        source?: string | undefined;
+        transport?: "durable_event" | "direct" | "relay" | undefined;
+        binding?: {
+            image_revision: "required" | "optional";
+        } | undefined;
+        confidence?: "high" | "medium" | "low" | undefined;
+        note?: string | undefined;
+    }, {
+        anchor: string;
+        id: string;
+        kind: "code" | "test" | "durable_event" | "e2e" | "metric" | "trace" | "log" | "spec" | "issue";
+        source?: string | undefined;
+        transport?: "durable_event" | "direct" | "relay" | undefined;
+        binding?: {
+            image_revision: "required" | "optional";
+        } | undefined;
+        confidence?: "high" | "medium" | "low" | undefined;
+        note?: string | undefined;
+    }>, "many">>;
+    status: z.ZodDefault<z.ZodEnum<["conformant", "unimplemented", "unverified", "drifted", "unregistered", "deprecated"]>>;
+}, "strip", z.ZodTypeAny, {
+    status: "conformant" | "unimplemented" | "unverified" | "drifted" | "unregistered" | "deprecated";
+    id: string;
+    kind: "junction";
+    scenarios: string[];
+    risk_class: "handoff" | "idempotency" | "projection" | "failure_propagation" | "watchdog";
+    between: string[];
+    evidence: {
+        anchor: string;
+        id: string;
+        kind: "code" | "test" | "durable_event" | "e2e" | "metric" | "trace" | "log" | "spec" | "issue";
+        source?: string | undefined;
+        transport?: "durable_event" | "direct" | "relay" | undefined;
+        binding?: {
+            image_revision: "required" | "optional";
+        } | undefined;
+        confidence?: "high" | "medium" | "low" | undefined;
+        note?: string | undefined;
+    }[];
+    title?: string | undefined;
+}, {
+    id: string;
+    kind: "junction";
+    risk_class: "handoff" | "idempotency" | "projection" | "failure_propagation" | "watchdog";
+    between: string[];
+    status?: "conformant" | "unimplemented" | "unverified" | "drifted" | "unregistered" | "deprecated" | undefined;
+    title?: string | undefined;
+    scenarios?: string[] | undefined;
+    evidence?: {
+        anchor: string;
+        id: string;
+        kind: "code" | "test" | "durable_event" | "e2e" | "metric" | "trace" | "log" | "spec" | "issue";
+        source?: string | undefined;
+        transport?: "durable_event" | "direct" | "relay" | undefined;
+        binding?: {
+            image_revision: "required" | "optional";
+        } | undefined;
+        confidence?: "high" | "medium" | "low" | undefined;
+        note?: string | undefined;
+    }[] | undefined;
+}>, z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"scenario">;
+    given: z.ZodString;
+    when: z.ZodString;
+    then: z.ZodString;
+    level: z.ZodEnum<["unit", "focused-integration", "contract", "integration", "e2e", "operational"]>;
+    verified_by: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    applies_to: z.ZodOptional<z.ZodObject<{
+        nodes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        owner_match: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        nodes: string[];
+        owner_match?: string | undefined;
+    }, {
+        nodes?: string[] | undefined;
+        owner_match?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    then: string;
+    id: string;
+    kind: "scenario";
+    given: string;
+    when: string;
+    level: "e2e" | "unit" | "focused-integration" | "contract" | "integration" | "operational";
+    verified_by: string[];
+    applies_to?: {
+        nodes: string[];
+        owner_match?: string | undefined;
+    } | undefined;
+}, {
+    then: string;
+    id: string;
+    kind: "scenario";
+    given: string;
+    when: string;
+    level: "e2e" | "unit" | "focused-integration" | "contract" | "integration" | "operational";
+    verified_by?: string[] | undefined;
+    applies_to?: {
+        nodes?: string[] | undefined;
+        owner_match?: string | undefined;
+    } | undefined;
+}>, z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"debt">;
+    category: z.ZodEnum<["dead_state_machine", "deferred", "other"]>;
+    subject: z.ZodString;
+    claim: z.ZodOptional<z.ZodString>;
+    reality: z.ZodString;
+    owner: z.ZodOptional<z.ZodString>;
+    removal_condition: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    kind: "debt";
+    category: "dead_state_machine" | "deferred" | "other";
+    subject: string;
+    reality: string;
+    owner?: string | undefined;
+    claim?: string | undefined;
+    removal_condition?: string | undefined;
+}, {
+    id: string;
+    kind: "debt";
+    category: "dead_state_machine" | "deferred" | "other";
+    subject: string;
+    reality: string;
+    owner?: string | undefined;
+    claim?: string | undefined;
+    removal_condition?: string | undefined;
+}>]>;
+export type ModelNode = z.infer<typeof ModelNode>;
+//# sourceMappingURL=model.d.ts.map