@anlyx/core 0.1.3 → 0.1.5

package/dist/flow-spec/schema.d.ts

@@ -0,0 +1,502 @@
+import { z } from "zod";
+export declare const flowNodeTypeSchema: z.ZodEnum<{
+    unknown: "unknown";
+    controller: "controller";
+    middleware: "middleware";
+    service: "service";
+    repository: "repository";
+    external: "external";
+    queue: "queue";
+    job: "job";
+    database: "database";
+    response: "response";
+    result: "result";
+    "ui.action": "ui.action";
+    "ui.page": "ui.page";
+    "ui.component": "ui.component";
+    "api.request": "api.request";
+    "api.route": "api.route";
+    "auth.session": "auth.session";
+}>;
+export declare const flowStatusSchema: z.ZodEnum<{
+    unknown: "unknown";
+    manual: "manual";
+    observed: "observed";
+    measured: "measured";
+    "source-matched": "source-matched";
+    "agent-inferred": "agent-inferred";
+    "not-proven": "not-proven";
+}>;
+export declare const flowEvidenceKindSchema: z.ZodEnum<{
+    unknown: "unknown";
+    manual: "manual";
+    agent: "agent";
+    source: "source";
+    "runtime.browser.click": "runtime.browser.click";
+    "runtime.browser.fetch": "runtime.browser.fetch";
+    "runtime.server.span": "runtime.server.span";
+    "runtime.database.query": "runtime.database.query";
+    "telemetry.span": "telemetry.span";
+}>;
+export declare const flowTimingSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"measured">;
+    durationMs: z.ZodNumber;
+    evidenceId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"estimate">;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    reason: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"unknown">;
+}, z.core.$strict>], "kind">;
+export declare const flowSourceLocationSchema: z.ZodObject<{
+    file: z.ZodOptional<z.ZodString>;
+    symbol: z.ZodOptional<z.ZodString>;
+    lineStart: z.ZodOptional<z.ZodNumber>;
+    lineEnd: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const flowEvidenceSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        unknown: "unknown";
+        manual: "manual";
+        agent: "agent";
+        source: "source";
+        "runtime.browser.click": "runtime.browser.click";
+        "runtime.browser.fetch": "runtime.browser.fetch";
+        "runtime.server.span": "runtime.server.span";
+        "runtime.database.query": "runtime.database.query";
+        "telemetry.span": "telemetry.span";
+    }>;
+    label: z.ZodOptional<z.ZodString>;
+    file: z.ZodOptional<z.ZodString>;
+    symbol: z.ZodOptional<z.ZodString>;
+    lineStart: z.ZodOptional<z.ZodNumber>;
+    lineEnd: z.ZodOptional<z.ZodNumber>;
+    observedAt: z.ZodOptional<z.ZodString>;
+    detail: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const flowRequestSchema: z.ZodObject<{
+    pathParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    body: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strict>;
+export declare const flowResponseSchema: z.ZodObject<{
+    statusCodes: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    bodyShape: z.ZodOptional<z.ZodUnknown>;
+    source: z.ZodOptional<z.ZodObject<{
+        file: z.ZodOptional<z.ZodString>;
+        symbol: z.ZodOptional<z.ZodString>;
+        lineStart: z.ZodOptional<z.ZodNumber>;
+        lineEnd: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const flowNodeSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+        unknown: "unknown";
+        controller: "controller";
+        middleware: "middleware";
+        service: "service";
+        repository: "repository";
+        external: "external";
+        queue: "queue";
+        job: "job";
+        database: "database";
+        response: "response";
+        result: "result";
+        "ui.action": "ui.action";
+        "ui.page": "ui.page";
+        "ui.component": "ui.component";
+        "api.request": "api.request";
+        "api.route": "api.route";
+        "auth.session": "auth.session";
+    }>;
+    label: z.ZodString;
+    status: z.ZodDefault<z.ZodEnum<{
+        unknown: "unknown";
+        manual: "manual";
+        observed: "observed";
+        measured: "measured";
+        "source-matched": "source-matched";
+        "agent-inferred": "agent-inferred";
+        "not-proven": "not-proven";
+    }>>;
+    evidenceIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    timing: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"measured">;
+        durationMs: z.ZodNumber;
+        evidenceId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"estimate">;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        reason: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"unknown">;
+    }, z.core.$strict>], "kind">>;
+    request: z.ZodOptional<z.ZodObject<{
+        pathParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        body: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>>;
+    response: z.ZodOptional<z.ZodObject<{
+        statusCodes: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        bodyShape: z.ZodOptional<z.ZodUnknown>;
+        source: z.ZodOptional<z.ZodObject<{
+            file: z.ZodOptional<z.ZodString>;
+            symbol: z.ZodOptional<z.ZodString>;
+            lineStart: z.ZodOptional<z.ZodNumber>;
+            lineEnd: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export declare const flowEdgeSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    from: z.ZodString;
+    to: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    status: z.ZodDefault<z.ZodEnum<{
+        unknown: "unknown";
+        manual: "manual";
+        observed: "observed";
+        measured: "measured";
+        "source-matched": "source-matched";
+        "agent-inferred": "agent-inferred";
+        "not-proven": "not-proven";
+    }>>;
+    evidenceIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    timing: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"measured">;
+        durationMs: z.ZodNumber;
+        evidenceId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"estimate">;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        reason: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"unknown">;
+    }, z.core.$strict>], "kind">>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export declare const flowEntrySchema: z.ZodObject<{
+    type: z.ZodString;
+    label: z.ZodString;
+    page: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const flowSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    entry: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        label: z.ZodString;
+        page: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<{
+            unknown: "unknown";
+            controller: "controller";
+            middleware: "middleware";
+            service: "service";
+            repository: "repository";
+            external: "external";
+            queue: "queue";
+            job: "job";
+            database: "database";
+            response: "response";
+            result: "result";
+            "ui.action": "ui.action";
+            "ui.page": "ui.page";
+            "ui.component": "ui.component";
+            "api.request": "api.request";
+            "api.route": "api.route";
+            "auth.session": "auth.session";
+        }>;
+        label: z.ZodString;
+        status: z.ZodDefault<z.ZodEnum<{
+            unknown: "unknown";
+            manual: "manual";
+            observed: "observed";
+            measured: "measured";
+            "source-matched": "source-matched";
+            "agent-inferred": "agent-inferred";
+            "not-proven": "not-proven";
+        }>>;
+        evidenceIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        timing: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"measured">;
+            durationMs: z.ZodNumber;
+            evidenceId: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"estimate">;
+            durationMs: z.ZodOptional<z.ZodNumber>;
+            reason: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"unknown">;
+        }, z.core.$strict>], "kind">>;
+        request: z.ZodOptional<z.ZodObject<{
+            pathParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            body: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strict>>;
+        response: z.ZodOptional<z.ZodObject<{
+            statusCodes: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+            bodyShape: z.ZodOptional<z.ZodUnknown>;
+            source: z.ZodOptional<z.ZodObject<{
+                file: z.ZodOptional<z.ZodString>;
+                symbol: z.ZodOptional<z.ZodString>;
+                lineStart: z.ZodOptional<z.ZodNumber>;
+                lineEnd: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>;
+    edges: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        from: z.ZodString;
+        to: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        status: z.ZodDefault<z.ZodEnum<{
+            unknown: "unknown";
+            manual: "manual";
+            observed: "observed";
+            measured: "measured";
+            "source-matched": "source-matched";
+            "agent-inferred": "agent-inferred";
+            "not-proven": "not-proven";
+        }>>;
+        evidenceIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        timing: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"measured">;
+            durationMs: z.ZodNumber;
+            evidenceId: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"estimate">;
+            durationMs: z.ZodOptional<z.ZodNumber>;
+            reason: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"unknown">;
+        }, z.core.$strict>], "kind">>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>;
+    evidence: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            unknown: "unknown";
+            manual: "manual";
+            agent: "agent";
+            source: "source";
+            "runtime.browser.click": "runtime.browser.click";
+            "runtime.browser.fetch": "runtime.browser.fetch";
+            "runtime.server.span": "runtime.server.span";
+            "runtime.database.query": "runtime.database.query";
+            "telemetry.span": "telemetry.span";
+        }>;
+        label: z.ZodOptional<z.ZodString>;
+        file: z.ZodOptional<z.ZodString>;
+        symbol: z.ZodOptional<z.ZodString>;
+        lineStart: z.ZodOptional<z.ZodNumber>;
+        lineEnd: z.ZodOptional<z.ZodNumber>;
+        observedAt: z.ZodOptional<z.ZodString>;
+        detail: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const flowProjectSchema: z.ZodObject<{
+    name: z.ZodString;
+    root: z.ZodDefault<z.ZodString>;
+    frameworks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const flowGeneratedBySchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        unknown: "unknown";
+        manual: "manual";
+        agent: "agent";
+        runtime: "runtime";
+        adapter: "adapter";
+    }>;
+    name: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodString>;
+    skill: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const flowSnapshotSchema: z.ZodObject<{
+    id: z.ZodString;
+    createdAt: z.ZodString;
+    source: z.ZodString;
+    git: z.ZodOptional<z.ZodObject<{
+        branch: z.ZodOptional<z.ZodString>;
+        commit: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const anlyxFlowFileSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"0.1.5">;
+    project: z.ZodObject<{
+        name: z.ZodString;
+        root: z.ZodDefault<z.ZodString>;
+        frameworks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
+    generatedBy: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            unknown: "unknown";
+            manual: "manual";
+            agent: "agent";
+            runtime: "runtime";
+            adapter: "adapter";
+        }>;
+        name: z.ZodOptional<z.ZodString>;
+        version: z.ZodOptional<z.ZodString>;
+        skill: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    snapshot: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        createdAt: z.ZodString;
+        source: z.ZodString;
+        git: z.ZodOptional<z.ZodObject<{
+            branch: z.ZodOptional<z.ZodString>;
+            commit: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    flows: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        entry: z.ZodOptional<z.ZodObject<{
+            type: z.ZodString;
+            label: z.ZodString;
+            page: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        nodes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodEnum<{
+                unknown: "unknown";
+                controller: "controller";
+                middleware: "middleware";
+                service: "service";
+                repository: "repository";
+                external: "external";
+                queue: "queue";
+                job: "job";
+                database: "database";
+                response: "response";
+                result: "result";
+                "ui.action": "ui.action";
+                "ui.page": "ui.page";
+                "ui.component": "ui.component";
+                "api.request": "api.request";
+                "api.route": "api.route";
+                "auth.session": "auth.session";
+            }>;
+            label: z.ZodString;
+            status: z.ZodDefault<z.ZodEnum<{
+                unknown: "unknown";
+                manual: "manual";
+                observed: "observed";
+                measured: "measured";
+                "source-matched": "source-matched";
+                "agent-inferred": "agent-inferred";
+                "not-proven": "not-proven";
+            }>>;
+            evidenceIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            timing: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"measured">;
+                durationMs: z.ZodNumber;
+                evidenceId: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"estimate">;
+                durationMs: z.ZodOptional<z.ZodNumber>;
+                reason: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"unknown">;
+            }, z.core.$strict>], "kind">>;
+            request: z.ZodOptional<z.ZodObject<{
+                pathParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                body: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strict>>;
+            response: z.ZodOptional<z.ZodObject<{
+                statusCodes: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                bodyShape: z.ZodOptional<z.ZodUnknown>;
+                source: z.ZodOptional<z.ZodObject<{
+                    file: z.ZodOptional<z.ZodString>;
+                    symbol: z.ZodOptional<z.ZodString>;
+                    lineStart: z.ZodOptional<z.ZodNumber>;
+                    lineEnd: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>>;
+        edges: z.ZodArray<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            from: z.ZodString;
+            to: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            status: z.ZodDefault<z.ZodEnum<{
+                unknown: "unknown";
+                manual: "manual";
+                observed: "observed";
+                measured: "measured";
+                "source-matched": "source-matched";
+                "agent-inferred": "agent-inferred";
+                "not-proven": "not-proven";
+            }>>;
+            evidenceIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            timing: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"measured">;
+                durationMs: z.ZodNumber;
+                evidenceId: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"estimate">;
+                durationMs: z.ZodOptional<z.ZodNumber>;
+                reason: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"unknown">;
+            }, z.core.$strict>], "kind">>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>>;
+        evidence: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                unknown: "unknown";
+                manual: "manual";
+                agent: "agent";
+                source: "source";
+                "runtime.browser.click": "runtime.browser.click";
+                "runtime.browser.fetch": "runtime.browser.fetch";
+                "runtime.server.span": "runtime.server.span";
+                "runtime.database.query": "runtime.database.query";
+                "telemetry.span": "telemetry.span";
+            }>;
+            label: z.ZodOptional<z.ZodString>;
+            file: z.ZodOptional<z.ZodString>;
+            symbol: z.ZodOptional<z.ZodString>;
+            lineStart: z.ZodOptional<z.ZodNumber>;
+            lineEnd: z.ZodOptional<z.ZodNumber>;
+            observedAt: z.ZodOptional<z.ZodString>;
+            detail: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type FlowNodeType = z.infer<typeof flowNodeTypeSchema>;
+export type FlowStatus = z.infer<typeof flowStatusSchema>;
+export type FlowEvidenceKind = z.infer<typeof flowEvidenceKindSchema>;
+export type FlowTiming = z.infer<typeof flowTimingSchema>;
+export type FlowSourceLocation = z.infer<typeof flowSourceLocationSchema>;
+export type FlowEvidence = z.infer<typeof flowEvidenceSchema>;
+export type FlowRequest = z.infer<typeof flowRequestSchema>;
+export type FlowResponse = z.infer<typeof flowResponseSchema>;
+export type FlowNode = z.infer<typeof flowNodeSchema>;
+export type FlowEdge = z.infer<typeof flowEdgeSchema>;
+export type FlowEntry = z.infer<typeof flowEntrySchema>;
+export type FlowProject = z.infer<typeof flowProjectSchema>;
+export type FlowGeneratedBy = z.infer<typeof flowGeneratedBySchema>;
+export type FlowSnapshot = z.infer<typeof flowSnapshotSchema>;
+export type Flow = z.infer<typeof flowSchema>;
+export type AnlyxFlowFile = z.infer<typeof anlyxFlowFileSchema>;
+export declare function parseAnlyxFlowFile(value: unknown): AnlyxFlowFile;
+export declare function parseFlow(value: unknown): Flow;
+//# sourceMappingURL=schema.d.ts.map

package/dist/flow-spec/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/flow-spec/schema.ts"],"names":[],"mappings":"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"}

package/dist/flow-spec/schema.js

@@ -0,0 +1,186 @@
+import { z } from "zod";
+export const flowNodeTypeSchema = z.enum([
+    "ui.action",
+    "ui.page",
+    "ui.component",
+    "api.request",
+    "api.route",
+    "controller",
+    "middleware",
+    "auth.session",
+    "service",
+    "repository",
+    "database",
+    "external",
+    "queue",
+    "job",
+    "result",
+    "response",
+    "unknown"
+]);
+export const flowStatusSchema = z.enum([
+    "observed",
+    "measured",
+    "source-matched",
+    "agent-inferred",
+    "manual",
+    "not-proven",
+    "unknown"
+]);
+export const flowEvidenceKindSchema = z.enum([
+    "runtime.browser.click",
+    "runtime.browser.fetch",
+    "runtime.server.span",
+    "runtime.database.query",
+    "telemetry.span",
+    "source",
+    "agent",
+    "manual",
+    "unknown"
+]);
+export const flowTimingSchema = z.discriminatedUnion("kind", [
+    z
+        .object({
+        kind: z.literal("measured"),
+        durationMs: z.number().nonnegative(),
+        evidenceId: z.string().min(1)
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("estimate"),
+        durationMs: z.number().nonnegative().optional(),
+        reason: z.string().min(1)
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("unknown")
+    })
+        .strict()
+]);
+const recordSchema = z.record(z.string(), z.unknown());
+export const flowSourceLocationSchema = z
+    .object({
+    file: z.string().optional(),
+    symbol: z.string().optional(),
+    lineStart: z.number().int().positive().optional(),
+    lineEnd: z.number().int().positive().optional()
+})
+    .strict();
+export const flowEvidenceSchema = z
+    .object({
+    id: z.string().min(1),
+    kind: flowEvidenceKindSchema,
+    label: z.string().optional(),
+    file: z.string().optional(),
+    symbol: z.string().optional(),
+    lineStart: z.number().int().positive().optional(),
+    lineEnd: z.number().int().positive().optional(),
+    observedAt: z.string().optional(),
+    detail: z.string().optional()
+})
+    .strict();
+export const flowRequestSchema = z
+    .object({
+    pathParams: recordSchema.optional(),
+    query: recordSchema.optional(),
+    headers: recordSchema.optional(),
+    body: z.unknown().optional()
+})
+    .strict();
+export const flowResponseSchema = z
+    .object({
+    statusCodes: z.array(z.number().int()).optional(),
+    bodyShape: z.unknown().optional(),
+    source: flowSourceLocationSchema.optional()
+})
+    .strict();
+export const flowNodeSchema = z
+    .object({
+    id: z.string().min(1),
+    type: flowNodeTypeSchema,
+    label: z.string().min(1),
+    status: flowStatusSchema.default("unknown"),
+    evidenceIds: z.array(z.string().min(1)).optional(),
+    timing: flowTimingSchema.optional(),
+    request: flowRequestSchema.optional(),
+    response: flowResponseSchema.optional(),
+    metadata: recordSchema.optional()
+})
+    .strict();
+export const flowEdgeSchema = z
+    .object({
+    id: z.string().min(1).optional(),
+    from: z.string().min(1),
+    to: z.string().min(1),
+    label: z.string().optional(),
+    status: flowStatusSchema.default("unknown"),
+    evidenceIds: z.array(z.string().min(1)).optional(),
+    timing: flowTimingSchema.optional(),
+    metadata: recordSchema.optional()
+})
+    .strict();
+export const flowEntrySchema = z
+    .object({
+    type: z.string().min(1),
+    label: z.string().min(1),
+    page: z.string().optional()
+})
+    .strict();
+export const flowSchema = z
+    .object({
+    id: z.string().min(1),
+    title: z.string().min(1),
+    description: z.string().optional(),
+    entry: flowEntrySchema.optional(),
+    nodes: z.array(flowNodeSchema),
+    edges: z.array(flowEdgeSchema),
+    evidence: z.array(flowEvidenceSchema)
+})
+    .strict();
+export const flowProjectSchema = z
+    .object({
+    name: z.string().min(1),
+    root: z.string().default("."),
+    frameworks: z.array(z.string()).optional()
+})
+    .strict();
+export const flowGeneratedBySchema = z
+    .object({
+    type: z.enum(["agent", "manual", "runtime", "adapter", "unknown"]),
+    name: z.string().optional(),
+    version: z.string().optional(),
+    skill: z.string().optional()
+})
+    .strict();
+export const flowSnapshotSchema = z
+    .object({
+    id: z.string().min(1),
+    createdAt: z.string().min(1),
+    source: z.string().min(1),
+    git: z
+        .object({
+        branch: z.string().optional(),
+        commit: z.string().optional()
+    })
+        .strict()
+        .optional()
+})
+    .strict();
+export const anlyxFlowFileSchema = z
+    .object({
+    schemaVersion: z.literal("0.1.5"),
+    project: flowProjectSchema,
+    generatedBy: flowGeneratedBySchema.optional(),
+    snapshot: flowSnapshotSchema.optional(),
+    flows: z.array(flowSchema)
+})
+    .strict();
+export function parseAnlyxFlowFile(value) {
+    return anlyxFlowFileSchema.parse(value);
+}
+export function parseFlow(value) {
+    return flowSchema.parse(value);
+}
+//# sourceMappingURL=schema.js.map