peer-ai-workflow 1.0.0-next.0

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+import type { z } from "zod";
+import { ConfigLayerSchema, type PeerAiConfig } from "./config.ts";
+import { type ReviewReport } from "./report.ts";
+import { type ProjectMap, type WorkItem } from "./state.ts";
+export * from "./ids.ts";
+export { ConfigLayerSchema, ConfigSchema, mergeConfigs, resolveConfig, type PeerAiConfig } from "./config.ts";
+export { ReviewReportSchema, SEVERITIES, deriveResult, type ReviewReport, type ReviewResult, type Severity, } from "./report.ts";
+export { MapItemIdSchema, MapSchema, WorkItemIdSchema, WorkItemSchema, type ProjectMap, type WorkItem, } from "./state.ts";
+export type Validation<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    errors: string[];
+};
+/** Validates a resolved config: one with no `extends` left, or the result of `resolveConfig`. */
+export declare const validateConfig: (input: unknown) => Validation<PeerAiConfig>;
+export declare const CONFIG_FILE = "peer-ai.config.json";
+/** Reads peer-ai.config.json, following a relative `extends`. Returns errors instead of throwing. */
+export declare function readConfig(root: string): {
+    config?: PeerAiConfig;
+    errors?: string[];
+};
+export declare const validateConfigLayer: (input: unknown) => Validation<z.output<typeof ConfigLayerSchema>>;
+export declare const validateMap: (input: unknown) => Validation<ProjectMap>;
+export declare const validateWorkItem: (input: unknown) => Validation<WorkItem>;
+export declare const validateReport: (input: unknown) => Validation<ReviewReport>;

package/dist/index.js

@@ -0,0 +1,51 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { ConfigLayerSchema, ConfigSchema, resolveConfig } from "./config.js";
+import { ReviewReportSchema } from "./report.js";
+import { MapSchema, WorkItemSchema } from "./state.js";
+export * from "./ids.js";
+export { ConfigLayerSchema, ConfigSchema, mergeConfigs, resolveConfig } from "./config.js";
+export { ReviewReportSchema, SEVERITIES, deriveResult, } from "./report.js";
+export { MapItemIdSchema, MapSchema, WorkItemIdSchema, WorkItemSchema, } from "./state.js";
+function validate(schema, input) {
+    const result = schema.safeParse(input);
+    if (result.success)
+        return { ok: true, value: result.data };
+    return {
+        ok: false,
+        errors: result.error.issues.map((issue) => {
+            const where = issue.path.length === 0 ? "(root)" : issue.path.map(String).join(".");
+            return `${where}: ${issue.message}`;
+        }),
+    };
+}
+/** Validates a resolved config: one with no `extends` left, or the result of `resolveConfig`. */
+export const validateConfig = (input) => validate(ConfigSchema, input);
+export const CONFIG_FILE = "peer-ai.config.json";
+/** Reads peer-ai.config.json, following a relative `extends`. Returns errors instead of throwing. */
+export function readConfig(root) {
+    const path = join(root, CONFIG_FILE);
+    if (!existsSync(path))
+        return {};
+    const readLayer = (file) => JSON.parse(readFileSync(file, "utf8"));
+    try {
+        const own = readLayer(path);
+        const layers = [];
+        if (typeof own.extends === "string") {
+            if (!own.extends.startsWith(".")) {
+                return { errors: [`extends: only a relative path is supported so far, not "${own.extends}"`] };
+            }
+            layers.push(readLayer(join(dirname(path), own.extends)));
+        }
+        layers.push(own);
+        const result = validateConfig(resolveConfig(layers));
+        return result.ok ? { config: result.value } : { errors: result.errors };
+    }
+    catch (error) {
+        return { errors: [error.message] };
+    }
+}
+export const validateConfigLayer = (input) => validate(ConfigLayerSchema, input);
+export const validateMap = (input) => validate(MapSchema, input);
+export const validateWorkItem = (input) => validate(WorkItemSchema, input);
+export const validateReport = (input) => validate(ReviewReportSchema, input);

package/dist/report.d.ts

@@ -0,0 +1,108 @@
+import { z } from "zod";
+/** How serious a problem is, most serious first. A review may not invent its own levels. */
+export declare const SEVERITIES: readonly ["critical", "high", "medium", "low"];
+export type Severity = (typeof SEVERITIES)[number];
+export type ReviewResult = "pass" | "fail" | "incomplete";
+export declare const ReviewReportSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    version: z.ZodLiteral<1>;
+    skill: z.ZodEnum<{
+        "requirements-analysis": "requirements-analysis";
+        "product-spec": "product-spec";
+        architecture: "architecture";
+        "system-design": "system-design";
+        "api-design": "api-design";
+        "data-modelling": "data-modelling";
+        "threat-model": "threat-model";
+        "design-system": "design-system";
+        "issue-planning": "issue-planning";
+        "implement-ticket": "implement-ticket";
+        "code-review": "code-review";
+        "security-review": "security-review";
+        "contract-check": "contract-check";
+        "accessibility-review": "accessibility-review";
+        "design-review": "design-review";
+        "performance-review": "performance-review";
+        "reliability-review": "reliability-review";
+        "data-migration-review": "data-migration-review";
+        "dependency-review": "dependency-review";
+        "compliance-review": "compliance-review";
+        "test-strategy": "test-strategy";
+        "qa-acceptance": "qa-acceptance";
+        "ai-feature-review": "ai-feature-review";
+        "release-readiness": "release-readiness";
+        "infrastructure-review": "infrastructure-review";
+        "observability-review": "observability-review";
+        "incident-response": "incident-response";
+        documentation: "documentation";
+        "tech-debt-triage": "tech-debt-triage";
+    }>;
+    workItem: z.ZodOptional<z.ZodString>;
+    at: z.ZodISODateTime;
+    scope: z.ZodObject<{
+        base: z.ZodOptional<z.ZodString>;
+        head: z.ZodOptional<z.ZodString>;
+        tracks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
+    inputs: z.ZodArray<z.ZodString>;
+    inventory: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodString;
+        location: z.ZodOptional<z.ZodObject<{
+            file: z.ZodString;
+            line: z.ZodOptional<z.ZodNumber>;
+            endLine: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    coverage: z.ZodArray<z.ZodObject<{
+        rule: z.ZodString;
+        item: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            pass: "pass";
+            fail: "fail";
+            "not-applicable": "not-applicable";
+            "not-checked": "not-checked";
+        }>;
+        evidence: z.ZodOptional<z.ZodString>;
+        finding: z.ZodOptional<z.ZodString>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    findings: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        rule: z.ZodString;
+        severity: z.ZodEnum<{
+            critical: "critical";
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>;
+        status: z.ZodEnum<{
+            fixed: "fixed";
+            open: "open";
+            accepted: "accepted";
+        }>;
+        title: z.ZodString;
+        location: z.ZodObject<{
+            file: z.ZodString;
+            line: z.ZodOptional<z.ZodNumber>;
+            endLine: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        evidence: z.ZodString;
+        fix: z.ZodOptional<z.ZodString>;
+        acceptedBy: z.ZodOptional<z.ZodString>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    result: z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+        incomplete: "incomplete";
+    }>;
+    summary: z.ZodString;
+}, z.core.$strict>;
+export type ReviewReport = z.output<typeof ReviewReportSchema>;
+/**
+ * The result a report supports: fail when an open problem is at or above the blocking level,
+ * incomplete when a rule wasn't checked, pass otherwise. Fixed and accepted problems don't block.
+ */
+export declare function deriveResult(report: ReviewReport, blockOn?: Severity): ReviewResult;

package/dist/report.js

@@ -0,0 +1,169 @@
+import { z } from "zod";
+import { SKILL_IDS } from "./ids.js";
+// A review report shows a review's work: what it looked at, what it read first, every rule it
+// checked and how each went, and every problem it found. Peer AI works out the review's result
+// from the report instead of taking the agent's word for it (RFC 0002).
+/** How serious a problem is, most serious first. A review may not invent its own levels. */
+export const SEVERITIES = ["critical", "high", "medium", "low"];
+const Path = z.string().min(1);
+const Timestamp = z.iso.datetime({ offset: true });
+const Text = z.string().min(1);
+const Location = z
+    .strictObject({
+    file: Path,
+    line: z.number().int().positive().optional(),
+    endLine: z.number().int().positive().optional(),
+})
+    .superRefine((location, ctx) => {
+    if (location.endLine === undefined)
+        return;
+    if (location.line === undefined || location.endLine < location.line) {
+        ctx.addIssue({ code: "custom", path: ["endLine"], message: "endLine needs a line, and can't come before it" });
+    }
+});
+const InventoryItem = z.strictObject({
+    id: Text.describe("A stable id for something under review, such as route:GET /orders/{id}."),
+    kind: Text.describe("What it is: a route, screen, migration, service, dependency, file and so on."),
+    location: Location.optional(),
+});
+const Coverage = z
+    .strictObject({
+    rule: Text.describe("The id of the rule checked."),
+    item: Text.optional().describe("The inventory id it was checked against. Omit it for the whole scope."),
+    status: z.enum(["pass", "fail", "not-applicable", "not-checked"]),
+    evidence: Text.optional().describe("For a pass: what was checked, and where."),
+    finding: Text.optional().describe("For a fail: the id of the problem found."),
+    reason: Text.optional().describe("For not-applicable or not-checked: why."),
+})
+    .superRefine((entry, ctx) => {
+    const need = (field, why) => {
+        if (entry[field] === undefined)
+            ctx.addIssue({ code: "custom", path: [field], message: why });
+    };
+    if (entry.status === "pass")
+        need("evidence", "a pass says what was checked");
+    if (entry.status === "fail")
+        need("finding", "a fail names the problem it found");
+    if (entry.status === "not-applicable")
+        need("reason", "say why the rule doesn't apply");
+    if (entry.status === "not-checked")
+        need("reason", "say why the rule wasn't checked");
+});
+const Finding = z
+    .strictObject({
+    id: Text,
+    rule: Text,
+    severity: z.enum(SEVERITIES),
+    status: z.enum(["open", "fixed", "accepted"]),
+    title: Text,
+    location: Location,
+    evidence: Text.describe("What shows the problem is real."),
+    fix: Text.optional().describe("A suggested fix."),
+    acceptedBy: Text.optional().describe("For an accepted risk: who accepted it."),
+    reason: Text.optional().describe("For an accepted risk: why it was accepted."),
+})
+    .superRefine((finding, ctx) => {
+    if (finding.status !== "accepted")
+        return;
+    if (finding.acceptedBy === undefined) {
+        ctx.addIssue({ code: "custom", path: ["acceptedBy"], message: "an accepted risk says who accepted it" });
+    }
+    if (finding.reason === undefined) {
+        ctx.addIssue({ code: "custom", path: ["reason"], message: "an accepted risk says why" });
+    }
+});
+export const ReviewReportSchema = z
+    .strictObject({
+    $schema: z.string().optional(),
+    version: z.literal(1),
+    skill: z.enum(SKILL_IDS),
+    workItem: z
+        .string()
+        .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/)
+        .optional()
+        .describe("The work item reviewed. Omit it for a review of the whole project."),
+    at: Timestamp,
+    scope: z
+        .strictObject({
+        base: Text.optional().describe("The commit the change starts from."),
+        head: Text.optional().describe("The commit reviewed."),
+        tracks: z.array(Text).optional(),
+        files: z.array(Path).optional(),
+    })
+        .describe("What was reviewed."),
+    inputs: z.array(Text).describe("Every document, profile, rule pack and decision the review read first."),
+    inventory: z.array(InventoryItem).describe("Everything under review."),
+    coverage: z.array(Coverage).min(1).describe("How each rule went. A rule is never left out silently."),
+    findings: z.array(Finding),
+    result: z.enum(["pass", "fail", "incomplete"]).describe("Must agree with the findings and coverage."),
+    summary: z.string().min(1).max(500).describe("A short summary for people."),
+})
+    .superRefine((report, ctx) => {
+    const items = new Set();
+    report.inventory.forEach((item, i) => {
+        if (items.has(item.id))
+            ctx.addIssue({ code: "custom", path: ["inventory", i, "id"], message: `duplicate id "${item.id}"` });
+        items.add(item.id);
+    });
+    const findings = new Map();
+    report.findings.forEach((finding, i) => {
+        if (findings.has(finding.id)) {
+            ctx.addIssue({ code: "custom", path: ["findings", i, "id"], message: `duplicate id "${finding.id}"` });
+        }
+        findings.set(finding.id, finding.rule);
+    });
+    const failed = new Set();
+    report.coverage.forEach((entry, i) => {
+        if (entry.item !== undefined && !items.has(entry.item)) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["coverage", i, "item"],
+                message: `"${entry.item}" is not in the inventory`,
+            });
+        }
+        if (entry.finding === undefined)
+            return;
+        const rule = findings.get(entry.finding);
+        if (rule === undefined) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["coverage", i, "finding"],
+                message: `"${entry.finding}" is not a finding`,
+            });
+        }
+        else if (rule !== entry.rule) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["coverage", i, "finding"],
+                message: `finding "${entry.finding}" is for rule ${rule}, not ${entry.rule}`,
+            });
+        }
+        failed.add(entry.finding);
+    });
+    report.findings.forEach((finding, i) => {
+        if (!failed.has(finding.id)) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["findings", i, "id"],
+                message: `no coverage entry fails for "${finding.id}"; every problem found is a failed check`,
+            });
+        }
+    });
+})
+    .meta({
+    title: "Peer AI review report",
+    description: ".peer-ai/reports/<work item>/<skill>-<time>.json: what a review looked at, every rule it checked, and every problem it found.",
+});
+/**
+ * The result a report supports: fail when an open problem is at or above the blocking level,
+ * incomplete when a rule wasn't checked, pass otherwise. Fixed and accepted problems don't block.
+ */
+export function deriveResult(report, blockOn = "critical") {
+    const blocking = SEVERITIES.indexOf(blockOn);
+    if (report.findings.some((finding) => finding.status === "open" && SEVERITIES.indexOf(finding.severity) <= blocking)) {
+        return "fail";
+    }
+    if (report.coverage.some((entry) => entry.status === "not-checked"))
+        return "incomplete";
+    return "pass";
+}

package/dist/state.d.ts

@@ -0,0 +1,261 @@
+import { z } from "zod";
+export declare const MapItemIdSchema: z.ZodUnion<readonly [z.ZodEnum<{
+    standards: "standards";
+    architecture: "architecture";
+    "threat-model": "threat-model";
+    requirements: "requirements";
+    specs: "specs";
+    "api-contract": "api-contract";
+    "data-model": "data-model";
+    "data-inventory": "data-inventory";
+    dpia: "dpia";
+    design: "design";
+    ci: "ci";
+    environments: "environments";
+    tests: "tests";
+    "load-testing": "load-testing";
+    infrastructure: "infrastructure";
+    observability: "observability";
+    slos: "slos";
+    runbooks: "runbooks";
+    docs: "docs";
+}>, z.ZodString]>;
+export declare const MapSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    version: z.ZodLiteral<1>;
+    assessedAt: z.ZodISODateTime;
+    items: z.ZodRecord<z.ZodUnion<readonly [z.ZodEnum<{
+        standards: "standards";
+        architecture: "architecture";
+        "threat-model": "threat-model";
+        requirements: "requirements";
+        specs: "specs";
+        "api-contract": "api-contract";
+        "data-model": "data-model";
+        "data-inventory": "data-inventory";
+        dpia: "dpia";
+        design: "design";
+        ci: "ci";
+        environments: "environments";
+        tests: "tests";
+        "load-testing": "load-testing";
+        infrastructure: "infrastructure";
+        observability: "observability";
+        slos: "slos";
+        runbooks: "runbooks";
+        docs: "docs";
+    }>, z.ZodString]> & z.core.$partial, z.ZodObject<{
+        status: z.ZodEnum<{
+            "not-applicable": "not-applicable";
+            present: "present";
+            partial: "partial";
+            missing: "missing";
+        }>;
+        evidence: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        inferred: z.ZodOptional<z.ZodBoolean>;
+        note: z.ZodOptional<z.ZodString>;
+        checkedAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const WorkItemIdSchema: z.ZodString;
+export declare const WorkItemSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    version: z.ZodLiteral<1>;
+    id: z.ZodString;
+    title: z.ZodString;
+    kind: z.ZodEnum<{
+        feature: "feature";
+        bug: "bug";
+        refactor: "refactor";
+        migration: "migration";
+        gap: "gap";
+        discovery: "discovery";
+        chore: "chore";
+    }>;
+    stage: z.ZodEnum<{
+        build: "build";
+        verify: "verify";
+        ship: "ship";
+        done: "done";
+        prepare: "prepare";
+        cancelled: "cancelled";
+    }>;
+    track: z.ZodOptional<z.ZodString>;
+    branch: z.ZodOptional<z.ZodString>;
+    gap: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        standards: "standards";
+        architecture: "architecture";
+        "threat-model": "threat-model";
+        requirements: "requirements";
+        specs: "specs";
+        "api-contract": "api-contract";
+        "data-model": "data-model";
+        "data-inventory": "data-inventory";
+        dpia: "dpia";
+        design: "design";
+        ci: "ci";
+        environments: "environments";
+        tests: "tests";
+        "load-testing": "load-testing";
+        infrastructure: "infrastructure";
+        observability: "observability";
+        slos: "slos";
+        runbooks: "runbooks";
+        docs: "docs";
+    }>, z.ZodString]>>;
+    goal: z.ZodOptional<z.ZodString>;
+    acceptance: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    sources: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    dependsOn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    activities: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodEnum<{
+            understand: "understand";
+            architect: "architect";
+            specify: "specify";
+            contract: "contract";
+            standards: "standards";
+            "delivery-setup": "delivery-setup";
+            plan: "plan";
+            build: "build";
+            verify: "verify";
+            test: "test";
+            ship: "ship";
+            operate: "operate";
+            document: "document";
+            retro: "retro";
+        }>;
+        status: z.ZodEnum<{
+            pending: "pending";
+            "in-progress": "in-progress";
+            done: "done";
+            skipped: "skipped";
+        }>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    position: z.ZodOptional<z.ZodObject<{
+        activity: z.ZodEnum<{
+            understand: "understand";
+            architect: "architect";
+            specify: "specify";
+            contract: "contract";
+            standards: "standards";
+            "delivery-setup": "delivery-setup";
+            plan: "plan";
+            build: "build";
+            verify: "verify";
+            test: "test";
+            ship: "ship";
+            operate: "operate";
+            document: "document";
+            retro: "retro";
+        }>;
+        step: z.ZodNumber;
+    }, z.core.$strict>>;
+    lastVerify: z.ZodOptional<z.ZodObject<{
+        result: z.ZodEnum<{
+            pass: "pass";
+            fail: "fail";
+        }>;
+        at: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    reviews: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        skill: z.ZodEnum<{
+            "requirements-analysis": "requirements-analysis";
+            "product-spec": "product-spec";
+            architecture: "architecture";
+            "system-design": "system-design";
+            "api-design": "api-design";
+            "data-modelling": "data-modelling";
+            "threat-model": "threat-model";
+            "design-system": "design-system";
+            "issue-planning": "issue-planning";
+            "implement-ticket": "implement-ticket";
+            "code-review": "code-review";
+            "security-review": "security-review";
+            "contract-check": "contract-check";
+            "accessibility-review": "accessibility-review";
+            "design-review": "design-review";
+            "performance-review": "performance-review";
+            "reliability-review": "reliability-review";
+            "data-migration-review": "data-migration-review";
+            "dependency-review": "dependency-review";
+            "compliance-review": "compliance-review";
+            "test-strategy": "test-strategy";
+            "qa-acceptance": "qa-acceptance";
+            "ai-feature-review": "ai-feature-review";
+            "release-readiness": "release-readiness";
+            "infrastructure-review": "infrastructure-review";
+            "observability-review": "observability-review";
+            "incident-response": "incident-response";
+            documentation: "documentation";
+            "tech-debt-triage": "tech-debt-triage";
+        }>;
+        result: z.ZodEnum<{
+            pass: "pass";
+            fail: "fail";
+            incomplete: "incomplete";
+        }>;
+        report: z.ZodOptional<z.ZodString>;
+        summary: z.ZodOptional<z.ZodString>;
+        unproven: z.ZodOptional<z.ZodBoolean>;
+        at: z.ZodISODateTime;
+    }, z.core.$strict>>>;
+    requiredReviews: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        skill: z.ZodEnum<{
+            "requirements-analysis": "requirements-analysis";
+            "product-spec": "product-spec";
+            architecture: "architecture";
+            "system-design": "system-design";
+            "api-design": "api-design";
+            "data-modelling": "data-modelling";
+            "threat-model": "threat-model";
+            "design-system": "design-system";
+            "issue-planning": "issue-planning";
+            "implement-ticket": "implement-ticket";
+            "code-review": "code-review";
+            "security-review": "security-review";
+            "contract-check": "contract-check";
+            "accessibility-review": "accessibility-review";
+            "design-review": "design-review";
+            "performance-review": "performance-review";
+            "reliability-review": "reliability-review";
+            "data-migration-review": "data-migration-review";
+            "dependency-review": "dependency-review";
+            "compliance-review": "compliance-review";
+            "test-strategy": "test-strategy";
+            "qa-acceptance": "qa-acceptance";
+            "ai-feature-review": "ai-feature-review";
+            "release-readiness": "release-readiness";
+            "infrastructure-review": "infrastructure-review";
+            "observability-review": "observability-review";
+            "incident-response": "incident-response";
+            documentation: "documentation";
+            "tech-debt-triage": "tech-debt-triage";
+        }>;
+        reason: z.ZodString;
+    }, z.core.$strict>>>;
+    reopened: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        activity: z.ZodEnum<{
+            understand: "understand";
+            architect: "architect";
+            specify: "specify";
+            contract: "contract";
+            standards: "standards";
+            "delivery-setup": "delivery-setup";
+            plan: "plan";
+            build: "build";
+            verify: "verify";
+            test: "test";
+            ship: "ship";
+            operate: "operate";
+            document: "document";
+            retro: "retro";
+        }>;
+        reason: z.ZodString;
+        at: z.ZodISODateTime;
+    }, z.core.$strict>>>;
+    next: z.ZodString;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type ProjectMap = z.output<typeof MapSchema>;
+export type WorkItem = z.output<typeof WorkItemSchema>;