@powerhousedao/knowledge-note 1.0.0

package/dist/document-models/observation/v1/src/index.js

@@ -0,0 +1 @@
+export * from "./utils.js";

package/dist/document-models/observation/v1/src/reducers/observation-management.d.ts

@@ -0,0 +1,3 @@
+import type { ObservationObservationManagementOperations } from "@powerhousedao/knowledge-note/document-models/observation/v1";
+export declare const observationObservationManagementOperations: ObservationObservationManagementOperations;
+//# sourceMappingURL=observation-management.d.ts.map

package/dist/document-models/observation/v1/src/reducers/observation-management.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observation-management.d.ts","sourceRoot":"","sources":["../../../../../../document-models/observation/v1/src/reducers/observation-management.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0CAA0C,EAAE,MAAM,8DAA8D,CAAC;AAE/H,eAAO,MAAM,0CAA0C,EAAE,0CAsBtD,CAAC"}

package/dist/document-models/observation/v1/src/reducers/observation-management.js

@@ -0,0 +1,22 @@
+export const observationObservationManagementOperations = {
+    createObservationOperation(state, action) {
+        state.title = action.input.title;
+        state.description = action.input.description;
+        state.content = action.input.content || null;
+        state.category = action.input.category;
+        state.status = "PENDING";
+        state.observedAt = action.input.observedAt;
+        state.observedBy = action.input.observedBy || null;
+    },
+    promoteObservationOperation(state, action) {
+        state.status = "PROMOTED";
+        state.promotedTo = action.input.promotedTo;
+        state.promotedAt = action.input.promotedAt;
+    },
+    implementObservationOperation(state, action) {
+        state.status = "IMPLEMENTED";
+    },
+    archiveObservationOperation(state, action) {
+        state.status = "ARCHIVED";
+    },
+};

package/dist/document-models/observation/v1/src/utils.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/dist/document-models/observation/v1/src/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../document-models/observation/v1/src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC"}

package/dist/document-models/observation/v1/src/utils.js

@@ -0,0 +1 @@
+export {};

package/dist/document-models/observation/v1/tests/document-model.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This is a scaffold file meant for customization:
+ * - change it by adding new tests or modifying the existing ones
+ */
+/**
+ * This is a scaffold file meant for customization:
+ * - change it by adding new tests or modifying the existing ones
+ */
+export {};
+//# sourceMappingURL=document-model.test.d.ts.map

package/dist/document-models/observation/v1/tests/document-model.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-model.test.d.ts","sourceRoot":"","sources":["../../../../../document-models/observation/v1/tests/document-model.test.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH;;;GAGG"}

package/dist/document-models/observation/v1/tests/document-model.test.js

@@ -0,0 +1,47 @@
+/**
+ * This is a scaffold file meant for customization:
+ * - change it by adding new tests or modifying the existing ones
+ */
+/**
+ * This is a scaffold file meant for customization:
+ * - change it by adding new tests or modifying the existing ones
+ */
+import { describe, it, expect } from "vitest";
+import { utils, initialGlobalState, initialLocalState, observationDocumentType, isObservationDocument, assertIsObservationDocument, isObservationState, assertIsObservationState, } from "@powerhousedao/knowledge-note/document-models/observation/v1";
+import { ZodError } from "zod";
+describe("Observation Document Model", () => {
+    it("should create a new Observation document", () => {
+        const document = utils.createDocument();
+        expect(document).toBeDefined();
+        expect(document.header.documentType).toBe(observationDocumentType);
+    });
+    it("should create a new Observation document with a valid initial state", () => {
+        const document = utils.createDocument();
+        expect(document.state.global).toStrictEqual(initialGlobalState);
+        expect(document.state.local).toStrictEqual(initialLocalState);
+        expect(isObservationDocument(document)).toBe(true);
+        expect(isObservationState(document.state)).toBe(true);
+    });
+    it("should reject a document that is not a Observation document", () => {
+        const wrongDocumentType = utils.createDocument();
+        wrongDocumentType.header.documentType = "the-wrong-thing-1234";
+        try {
+            expect(assertIsObservationDocument(wrongDocumentType)).toThrow();
+            expect(isObservationDocument(wrongDocumentType)).toBe(false);
+        }
+        catch (error) {
+            expect(error).toBeInstanceOf(ZodError);
+        }
+    });
+    it("should reject document with wrong document type", () => {
+        const wrongType = utils.createDocument();
+        wrongType.header.documentType = "wrong/type";
+        expect(isObservationDocument(wrongType)).toBe(false);
+    });
+    it("should reject missing header fields", () => {
+        const missingId = utils.createDocument();
+        // @ts-expect-error - testing error case
+        delete missingId.header.id;
+        expect(isObservationDocument(missingId)).toBe(false);
+    });
+});

package/dist/document-models/observation/v1/tests/observation-management.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=observation-management.test.d.ts.map

package/dist/document-models/observation/v1/tests/observation-management.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observation-management.test.d.ts","sourceRoot":"","sources":["../../../../../document-models/observation/v1/tests/observation-management.test.ts"],"names":[],"mappings":""}

package/dist/document-models/observation/v1/tests/observation-management.test.js

@@ -0,0 +1,45 @@
+import { generateMock } from "@powerhousedao/common/utils";
+import { describe, expect, it } from "vitest";
+import { reducer, utils, isObservationDocument, createObservation, promoteObservation, implementObservation, archiveObservation, CreateObservationInputSchema, PromoteObservationInputSchema, ImplementObservationInputSchema, ArchiveObservationInputSchema, } from "@powerhousedao/knowledge-note/document-models/observation/v1";
+describe("ObservationManagementOperations", () => {
+    it("should handle createObservation operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(CreateObservationInputSchema());
+        const updatedDocument = reducer(document, createObservation(input));
+        expect(isObservationDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("CREATE_OBSERVATION");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle promoteObservation operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(PromoteObservationInputSchema());
+        const updatedDocument = reducer(document, promoteObservation(input));
+        expect(isObservationDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("PROMOTE_OBSERVATION");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle implementObservation operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(ImplementObservationInputSchema());
+        const updatedDocument = reducer(document, implementObservation(input));
+        expect(isObservationDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("IMPLEMENT_OBSERVATION");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+    it("should handle archiveObservation operation", () => {
+        const document = utils.createDocument();
+        const input = generateMock(ArchiveObservationInputSchema());
+        const updatedDocument = reducer(document, archiveObservation(input));
+        expect(isObservationDocument(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.global).toHaveLength(1);
+        expect(updatedDocument.operations.global[0].action.type).toBe("ARCHIVE_OBSERVATION");
+        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    });
+});

package/dist/document-models/observation/v1/utils.d.ts

@@ -0,0 +1,14 @@
+import type { ObservationPHState } from "./gen/types.js";
+/** Utils for the Observation document model */
+export declare const utils: {
+    fileExtension: string;
+    createState: import("document-model").CreateState<ObservationPHState>;
+    createDocument: import("document-model").CreateDocument<ObservationPHState>;
+    loadFromInput: import("document-model").LoadFromInput<ObservationPHState>;
+    saveToFileHandle: import("document-model").SaveToFileHandle;
+    isStateOfType: import("document-model").IsStateOfType<ObservationPHState>;
+    assertIsStateOfType: import("document-model").AssertIsStateOfType<ObservationPHState>;
+    isDocumentOfType: import("document-model").IsDocumentOfType<ObservationPHState>;
+    assertIsDocumentOfType: import("document-model").AssertIsDocumentOfType<ObservationPHState>;
+};
+//# sourceMappingURL=utils.d.ts.map

package/dist/document-models/observation/v1/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../document-models/observation/v1/utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAIzD,+CAA+C;AAC/C,eAAO,MAAM,KAAK;;;;;;;;;;CAGgC,CAAC"}

package/dist/document-models/observation/v1/utils.js

@@ -0,0 +1,7 @@
+import { utils as genUtils } from "./gen/utils.js";
+import * as customUtils from "./src/utils.js";
+/** Utils for the Observation document model */
+export const utils = {
+    ...genUtils,
+    ...customUtils,
+};

package/dist/document-models/pipeline-queue/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./v1/index.js";
+export * from "./upgrades/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/document-models/pipeline-queue/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../document-models/pipeline-queue/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,qBAAqB,CAAC"}

package/dist/document-models/pipeline-queue/index.js

@@ -0,0 +1,2 @@
+export * from "./v1/index.js";
+export * from "./upgrades/index.js";

package/dist/document-models/pipeline-queue/upgrades/index.d.ts

@@ -0,0 +1,3 @@
+export { pipelineQueueUpgradeManifest } from "./upgrade-manifest.js";
+export { supportedVersions, latestVersion } from "./versions.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/document-models/pipeline-queue/upgrades/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../document-models/pipeline-queue/upgrades/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,4BAA4B,EAAE,MAAM,uBAAuB,CAAC;AACrE,OAAO,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC"}

package/dist/document-models/pipeline-queue/upgrades/index.js

@@ -0,0 +1,2 @@
+export { pipelineQueueUpgradeManifest } from "./upgrade-manifest.js";
+export { supportedVersions, latestVersion } from "./versions.js";

package/dist/document-models/pipeline-queue/upgrades/upgrade-manifest.d.ts

@@ -0,0 +1,4 @@
+import type { UpgradeManifest } from "document-model";
+import { supportedVersions } from "./versions.js";
+export declare const pipelineQueueUpgradeManifest: UpgradeManifest<typeof supportedVersions>;
+//# sourceMappingURL=upgrade-manifest.d.ts.map

package/dist/document-models/pipeline-queue/upgrades/upgrade-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upgrade-manifest.d.ts","sourceRoot":"","sources":["../../../../document-models/pipeline-queue/upgrades/upgrade-manifest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,EAAiB,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAEjE,eAAO,MAAM,4BAA4B,EAAE,eAAe,CACxD,OAAO,iBAAiB,CAMzB,CAAC"}

package/dist/document-models/pipeline-queue/upgrades/upgrade-manifest.js

@@ -0,0 +1,7 @@
+import { latestVersion, supportedVersions } from "./versions.js";
+export const pipelineQueueUpgradeManifest = {
+    documentType: "bai/pipeline-queue",
+    latestVersion,
+    supportedVersions,
+    upgrades: {},
+};

package/dist/document-models/pipeline-queue/upgrades/versions.d.ts

@@ -0,0 +1,3 @@
+export declare const supportedVersions: readonly [1];
+export declare const latestVersion: 1;
+//# sourceMappingURL=versions.d.ts.map

package/dist/document-models/pipeline-queue/upgrades/versions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"versions.d.ts","sourceRoot":"","sources":["../../../../document-models/pipeline-queue/upgrades/versions.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB,cAAe,CAAC;AAE9C,eAAO,MAAM,aAAa,GAAuB,CAAC"}

package/dist/document-models/pipeline-queue/upgrades/versions.js

@@ -0,0 +1,2 @@
+export const supportedVersions = [1];
+export const latestVersion = supportedVersions[0];

package/dist/document-models/pipeline-queue/v1/actions.d.ts

@@ -0,0 +1,21 @@
+/** Actions for the PipelineQueue document model */
+export declare const actions: {
+    addTask: (input: import("./index.js").AddTaskInput) => import("./index.js").AddTaskAction;
+    assignTask: (input: import("./index.js").AssignTaskInput) => import("./index.js").AssignTaskAction;
+    advancePhase: (input: import("./index.js").AdvancePhaseInput) => import("./index.js").AdvancePhaseAction;
+    completeTask: (input: import("./index.js").CompleteTaskInput) => import("./index.js").CompleteTaskAction;
+    failTask: (input: import("./index.js").FailTaskInput) => import("./index.js").FailTaskAction;
+    blockTask: (input: import("./index.js").BlockTaskInput) => import("./index.js").BlockTaskAction;
+    unblockTask: (input: import("./index.js").UnblockTaskInput) => import("./index.js").UnblockTaskAction;
+    setName: (name: string | {
+        name: string;
+    }) => import("document-model").SetNameAction;
+    undo: (count?: number, scope?: string) => import("document-model").UndoAction;
+    redo: (count?: number, scope?: string) => import("document-model").RedoAction;
+    prune: (start?: number, end?: number, scope?: string) => import("document-model").SchemaPruneAction;
+    loadState: <TState extends import("document-model").PHBaseState = import("document-model").PHBaseState>(state: TState & {
+        name: string;
+    }, operations: number) => import("document-model").LoadStateAction;
+    noop: (scope?: string) => import("document-model").NOOPAction;
+};
+//# sourceMappingURL=actions.d.ts.map

package/dist/document-models/pipeline-queue/v1/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../../../document-models/pipeline-queue/v1/actions.ts"],"names":[],"mappings":"AAGA,mDAAmD;AAEnD,eAAO,MAAM,OAAO;cAC6X,wCAAmB;iBAA4J,2CAAsB;mBAAuK,6CAAwB;mBAA6K,6CAAwB;eAAyK,yCAAoB;gBAA8J,0CAAqB;kBAAmK,4CAAuB;;;;gBAA88K,CAAC,eAAe,CAAC;gBAAkE,CAAC,eAAe,CAAC;iBAAmE,CAAC,aAAa,CAAC,eAAe,CAAC;;;;gBAAqS,CAAC;CAD13O,CAAC"}

package/dist/document-models/pipeline-queue/v1/actions.js

@@ -0,0 +1,4 @@
+import { baseActions } from "document-model";
+import { queueManagementActions } from "./gen/creators.js";
+/** Actions for the PipelineQueue document model */
+export const actions = { ...baseActions, ...queueManagementActions };

package/dist/document-models/pipeline-queue/v1/gen/actions.d.ts

@@ -0,0 +1,4 @@
+import type { PipelineQueueQueueManagementAction } from "./queue-management/actions.js";
+export * from "./queue-management/actions.js";
+export type PipelineQueueAction = PipelineQueueQueueManagementAction;
+//# sourceMappingURL=actions.d.ts.map

package/dist/document-models/pipeline-queue/v1/gen/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../../../../document-models/pipeline-queue/v1/gen/actions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,+BAA+B,CAAC;AAExF,cAAc,+BAA+B,CAAC;AAE9C,MAAM,MAAM,mBAAmB,GAAG,kCAAkC,CAAC"}

package/dist/document-models/pipeline-queue/v1/gen/actions.js

@@ -0,0 +1 @@
+export * from "./queue-management/actions.js";

package/dist/document-models/pipeline-queue/v1/gen/controller.d.ts

@@ -0,0 +1,4 @@
+import { PHDocumentController } from "document-model/core";
+import type { PipelineQueuePHState } from "./types.js";
+export declare const PipelineQueueController: new (initialDocument?: import("document-model").PHDocument<PipelineQueuePHState> | undefined) => PHDocumentController<PipelineQueuePHState> & import("document-model/core").ActionMap<import("./actions.js").PipelineQueueQueueManagementAction, PHDocumentController<PipelineQueuePHState>>;
+//# sourceMappingURL=controller.d.ts.map

package/dist/document-models/pipeline-queue/v1/gen/controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../../../../document-models/pipeline-queue/v1/gen/controller.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAE3D,OAAO,KAAK,EAAuB,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAE5E,eAAO,MAAM,uBAAuB,8RAGpB,CAAC"}

package/dist/document-models/pipeline-queue/v1/gen/controller.js

@@ -0,0 +1,3 @@
+import { PHDocumentController } from "document-model/core";
+import { PipelineQueue } from "../module.js";
+export const PipelineQueueController = PHDocumentController.forDocumentModel(PipelineQueue);

package/dist/document-models/pipeline-queue/v1/gen/creators.d.ts

@@ -0,0 +1,3 @@
+export * from "./queue-management/creators.js";
+export * as queueManagementActions from "./queue-management/creators.js";
+//# sourceMappingURL=creators.d.ts.map

package/dist/document-models/pipeline-queue/v1/gen/creators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"creators.d.ts","sourceRoot":"","sources":["../../../../../document-models/pipeline-queue/v1/gen/creators.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC;AAC/C,OAAO,KAAK,sBAAsB,MAAM,gCAAgC,CAAC"}

package/dist/document-models/pipeline-queue/v1/gen/creators.js

@@ -0,0 +1,2 @@
+export * from "./queue-management/creators.js";
+export * as queueManagementActions from "./queue-management/creators.js";

package/dist/document-models/pipeline-queue/v1/gen/document-model.d.ts

@@ -0,0 +1,3 @@
+import type { DocumentModelGlobalState } from "document-model";
+export declare const documentModel: DocumentModelGlobalState;
+//# sourceMappingURL=document-model.d.ts.map

package/dist/document-models/pipeline-queue/v1/gen/document-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-model.d.ts","sourceRoot":"","sources":["../../../../../document-models/pipeline-queue/v1/gen/document-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAE/D,eAAO,MAAM,aAAa,EAAE,wBAyL3B,CAAC"}

package/dist/document-models/pipeline-queue/v1/gen/document-model.js

@@ -0,0 +1,169 @@
+export const documentModel = {
+    id: "bai/pipeline-queue",
+    name: "PipelineQueue",
+    author: {
+        name: "BAI",
+        website: "https://bai.dev",
+    },
+    extension: "pq.phd",
+    description: "Processing pipeline state \u2014 singleton document per vault tracking tasks through extract, connect, reweave, and verify phases with handoff protocol.",
+    specifications: [
+        {
+            state: {
+                local: {
+                    schema: "",
+                    examples: [],
+                    initialValue: "",
+                },
+                global: {
+                    schema: "enum TaskStatus {\n    PENDING\n    IN_PROGRESS\n    BLOCKED\n    DONE\n    FAILED\n}\n\nenum LearningCategory {\n    FRICTION\n    SURPRISE\n    METHODOLOGY\n    PROCESS_GAP\n}\n\ntype PhaseLearning {\n    id: OID!\n    category: LearningCategory!\n    description: String!\n}\n\ntype PhaseHandoff {\n    id: OID!\n    phase: String!\n    workDone: String!\n    filesModified: [String!]!\n    learnings: [PhaseLearning!]!\n    completedAt: DateTime!\n    completedBy: String\n}\n\ntype PipelineTask {\n    id: OID!\n    taskType: String!\n    status: TaskStatus!\n    target: String!\n    batchId: String\n    documentRef: String\n    currentPhase: String\n    completedPhases: [String!]!\n    handoffs: [PhaseHandoff!]!\n    assignedTo: String\n    createdAt: DateTime!\n    updatedAt: DateTime\n}\n\ntype PhaseOrderEntry {\n    taskType: String!\n    phases: [String!]!\n}\n\ntype PipelineQueueState {\n    schemaVersion: Int!\n    phaseOrder: [PhaseOrderEntry!]!\n    tasks: [PipelineTask!]!\n    completedCount: Int!\n    activeCount: Int!\n    lastProcessedAt: DateTime\n}",
+                    examples: [],
+                    initialValue: '{\n    "schemaVersion": 3,\n    "phaseOrder": [\n        { "taskType": "claim", "phases": ["create", "reflect", "reweave", "verify"] },\n        { "taskType": "enrichment", "phases": ["enrich", "reflect", "reweave", "verify"] }\n    ],\n    "tasks": [],\n    "completedCount": 0,\n    "activeCount": 0,\n    "lastProcessedAt": null\n}',
+                },
+            },
+            modules: [
+                {
+                    id: "queue-management",
+                    name: "queue-management",
+                    description: "Pipeline task lifecycle and phase progression",
+                    operations: [
+                        {
+                            id: "add-task",
+                            name: "ADD_TASK",
+                            description: "Add a new task to the pipeline",
+                            schema: "input AddTaskInput {\n    id: OID!\n    taskType: String!\n    target: String!\n    batchId: String\n    documentRef: String\n    currentPhase: String\n    createdAt: DateTime!\n}",
+                            template: "Add a new task to the pipeline",
+                            reducer: 'const phaseEntry = state.phaseOrder.find(p => p.taskType === action.input.taskType);\nconst firstPhase = action.input.currentPhase || (phaseEntry ? phaseEntry.phases[0] : null);\nstate.tasks.push({\n    id: action.input.id,\n    taskType: action.input.taskType,\n    status: "PENDING",\n    target: action.input.target,\n    batchId: action.input.batchId || null,\n    documentRef: action.input.documentRef || null,\n    currentPhase: firstPhase || null,\n    completedPhases: [],\n    handoffs: [],\n    assignedTo: null,\n    createdAt: action.input.createdAt,\n    updatedAt: null,\n});\nstate.activeCount = (state.activeCount || 0) + 1;',
+                            errors: [],
+                            examples: [],
+                            scope: "global",
+                        },
+                        {
+                            id: "assign-task",
+                            name: "ASSIGN_TASK",
+                            description: "Assign task to a processor or user",
+                            schema: "input AssignTaskInput {\n    taskId: OID!\n    assignedTo: String!\n    updatedAt: DateTime!\n}",
+                            template: "Assign task to a processor or user",
+                            reducer: 'const task = state.tasks.find(t => t.id === action.input.taskId);\nif (!task) throw new TaskNotFoundError("Task not found");\ntask.assignedTo = action.input.assignedTo;\ntask.status = "IN_PROGRESS";\ntask.updatedAt = action.input.updatedAt;\nstate.lastProcessedAt = action.input.updatedAt;',
+                            errors: [
+                                {
+                                    id: "err-task-not-found-assign",
+                                    name: "TaskNotFoundError",
+                                    code: "TASK_NOT_FOUND",
+                                    description: "Task not found",
+                                    template: "",
+                                },
+                            ],
+                            examples: [],
+                            scope: "global",
+                        },
+                        {
+                            id: "advance-phase",
+                            name: "ADVANCE_PHASE",
+                            description: "Complete current phase, advance to next",
+                            schema: "input PhaseHandoffInput {\n    id: OID!\n    phase: String!\n    workDone: String!\n    filesModified: [String!]!\n    completedAt: DateTime!\n    completedBy: String\n}\n\ninput AdvancePhaseInput {\n    taskId: OID!\n    handoff: PhaseHandoffInput!\n    updatedAt: DateTime!\n}",
+                            template: "Complete current phase, advance to next",
+                            reducer: 'const task = state.tasks.find(t => t.id === action.input.taskId);\nif (!task) throw new TaskNotFoundError("Task not found");\nconst handoff = action.input.handoff;\ntask.handoffs.push({\n    id: handoff.id,\n    phase: handoff.phase,\n    workDone: handoff.workDone,\n    filesModified: handoff.filesModified,\n    learnings: [],\n    completedAt: handoff.completedAt,\n    completedBy: handoff.completedBy || null,\n});\nif (task.currentPhase) {\n    task.completedPhases.push(task.currentPhase);\n}\nconst phaseEntry = state.phaseOrder.find(p => p.taskType === task.taskType);\nif (phaseEntry) {\n    const currentIdx = phaseEntry.phases.indexOf(task.currentPhase || "");\n    const nextPhase = phaseEntry.phases[currentIdx + 1];\n    if (nextPhase) {\n        task.currentPhase = nextPhase;\n        task.status = "PENDING";\n    } else {\n        task.currentPhase = null;\n        task.status = "DONE";\n        state.completedCount = (state.completedCount || 0) + 1;\n        state.activeCount = Math.max(0, (state.activeCount || 0) - 1);\n    }\n}\ntask.assignedTo = null;\ntask.updatedAt = action.input.updatedAt;\nstate.lastProcessedAt = action.input.updatedAt;',
+                            errors: [
+                                {
+                                    id: "err-task-not-found-advance",
+                                    name: "TaskNotFoundError",
+                                    code: "TASK_NOT_FOUND",
+                                    description: "Task not found",
+                                    template: "",
+                                },
+                            ],
+                            examples: [],
+                            scope: "global",
+                        },
+                        {
+                            id: "complete-task",
+                            name: "COMPLETE_TASK",
+                            description: "Mark task as done",
+                            schema: "input CompleteTaskInput {\n    taskId: OID!\n    updatedAt: DateTime!\n}",
+                            template: "Mark task as done",
+                            reducer: 'const task = state.tasks.find(t => t.id === action.input.taskId);\nif (!task) throw new TaskNotFoundError("Task not found");\ntask.status = "DONE";\ntask.currentPhase = null;\ntask.updatedAt = action.input.updatedAt;\nstate.completedCount = (state.completedCount || 0) + 1;\nstate.activeCount = Math.max(0, (state.activeCount || 0) - 1);\nstate.lastProcessedAt = action.input.updatedAt;',
+                            errors: [
+                                {
+                                    id: "err-task-not-found-complete",
+                                    name: "TaskNotFoundError",
+                                    code: "TASK_NOT_FOUND",
+                                    description: "Task not found",
+                                    template: "",
+                                },
+                            ],
+                            examples: [],
+                            scope: "global",
+                        },
+                        {
+                            id: "fail-task",
+                            name: "FAIL_TASK",
+                            description: "Mark task as failed",
+                            schema: "input FailTaskInput {\n    taskId: OID!\n    reason: String!\n    updatedAt: DateTime!\n}",
+                            template: "Mark task as failed",
+                            reducer: 'const task = state.tasks.find(t => t.id === action.input.taskId);\nif (!task) throw new TaskNotFoundError("Task not found");\ntask.status = "FAILED";\ntask.updatedAt = action.input.updatedAt;\nstate.activeCount = Math.max(0, (state.activeCount || 0) - 1);\nstate.lastProcessedAt = action.input.updatedAt;',
+                            errors: [
+                                {
+                                    id: "err-task-not-found-fail",
+                                    name: "TaskNotFoundError",
+                                    code: "TASK_NOT_FOUND",
+                                    description: "Task not found",
+                                    template: "",
+                                },
+                            ],
+                            examples: [],
+                            scope: "global",
+                        },
+                        {
+                            id: "block-task",
+                            name: "BLOCK_TASK",
+                            description: "Mark task as blocked",
+                            schema: "input BlockTaskInput {\n    taskId: OID!\n    reason: String!\n    updatedAt: DateTime!\n}",
+                            template: "Mark task as blocked",
+                            reducer: 'const task = state.tasks.find(t => t.id === action.input.taskId);\nif (!task) throw new TaskNotFoundError("Task not found");\ntask.status = "BLOCKED";\ntask.updatedAt = action.input.updatedAt;',
+                            errors: [
+                                {
+                                    id: "err-task-not-found-block",
+                                    name: "TaskNotFoundError",
+                                    code: "TASK_NOT_FOUND",
+                                    description: "Task not found",
+                                    template: "",
+                                },
+                            ],
+                            examples: [],
+                            scope: "global",
+                        },
+                        {
+                            id: "unblock-task",
+                            name: "UNBLOCK_TASK",
+                            description: "Unblock a task",
+                            schema: "input UnblockTaskInput {\n    taskId: OID!\n    updatedAt: DateTime!\n}",
+                            template: "Unblock a task",
+                            reducer: 'const task = state.tasks.find(t => t.id === action.input.taskId);\nif (!task) throw new TaskNotFoundError("Task not found");\nif (task.status !== "BLOCKED") throw new InvalidTaskStatusError("Task is not blocked");\ntask.status = "PENDING";\ntask.updatedAt = action.input.updatedAt;',
+                            errors: [
+                                {
+                                    id: "err-task-not-found-unblock",
+                                    name: "TaskNotFoundError",
+                                    code: "TASK_NOT_FOUND",
+                                    description: "Task not found",
+                                    template: "",
+                                },
+                                {
+                                    id: "err-invalid-task-status",
+                                    name: "InvalidTaskStatusError",
+                                    code: "INVALID_TASK_STATUS",
+                                    description: "Task is not in the expected status",
+                                    template: "",
+                                },
+                            ],
+                            examples: [],
+                            scope: "global",
+                        },
+                    ],
+                },
+            ],
+            version: 1,
+            changeLog: [],
+        },
+    ],
+};

package/dist/document-models/pipeline-queue/v1/gen/document-schema.d.ts

@@ -0,0 +1,59 @@
+import { z } from "zod";
+import type { PipelineQueueDocument, PipelineQueuePHState } from "./types.js";
+/** Schema for validating the header object of a PipelineQueue document */
+export declare const PipelineQueueDocumentHeaderSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    createdAtUtcIso: z.ZodString;
+    lastModifiedAtUtcIso: z.ZodString;
+    documentType: z.ZodLiteral<"bai/pipeline-queue">;
+}, z.core.$strip>;
+/** Schema for validating the state object of a PipelineQueue document */
+export declare const PipelineQueuePHStateSchema: z.ZodObject<{
+    global: z.ZodObject<Required<{
+        activeCount: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
+        completedCount: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
+        lastProcessedAt: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+        phaseOrder: z.ZodType<import("./types.js").PhaseOrderEntry[], unknown, z.core.$ZodTypeInternals<import("./types.js").PhaseOrderEntry[], unknown>>;
+        schemaVersion: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
+        tasks: z.ZodType<import("./types.js").PipelineTask[], unknown, z.core.$ZodTypeInternals<import("./types.js").PipelineTask[], unknown>>;
+    }>, z.core.$strip>;
+}, z.core.$strip>;
+export declare const PipelineQueueDocumentSchema: z.ZodObject<{
+    header: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        createdAtUtcIso: z.ZodString;
+        lastModifiedAtUtcIso: z.ZodString;
+        documentType: z.ZodLiteral<"bai/pipeline-queue">;
+    }, z.core.$strip>;
+    state: z.ZodObject<{
+        global: z.ZodObject<Required<{
+            activeCount: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
+            completedCount: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
+            lastProcessedAt: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            phaseOrder: z.ZodType<import("./types.js").PhaseOrderEntry[], unknown, z.core.$ZodTypeInternals<import("./types.js").PhaseOrderEntry[], unknown>>;
+            schemaVersion: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
+            tasks: z.ZodType<import("./types.js").PipelineTask[], unknown, z.core.$ZodTypeInternals<import("./types.js").PipelineTask[], unknown>>;
+        }>, z.core.$strip>;
+    }, z.core.$strip>;
+    initialState: z.ZodObject<{
+        global: z.ZodObject<Required<{
+            activeCount: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
+            completedCount: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
+            lastProcessedAt: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            phaseOrder: z.ZodType<import("./types.js").PhaseOrderEntry[], unknown, z.core.$ZodTypeInternals<import("./types.js").PhaseOrderEntry[], unknown>>;
+            schemaVersion: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
+            tasks: z.ZodType<import("./types.js").PipelineTask[], unknown, z.core.$ZodTypeInternals<import("./types.js").PipelineTask[], unknown>>;
+        }>, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/** Simple helper function to check if a state object is a PipelineQueue document state object */
+export declare function isPipelineQueueState(state: unknown): state is PipelineQueuePHState;
+/** Simple helper function to assert that a document state object is a PipelineQueue document state object */
+export declare function assertIsPipelineQueueState(state: unknown): asserts state is PipelineQueuePHState;
+/** Simple helper function to check if a document is a PipelineQueue document */
+export declare function isPipelineQueueDocument(document: unknown): document is PipelineQueueDocument;
+/** Simple helper function to assert that a document is a PipelineQueue document */
+export declare function assertIsPipelineQueueDocument(document: unknown): asserts document is PipelineQueueDocument;
+//# sourceMappingURL=document-schema.d.ts.map

package/dist/document-models/pipeline-queue/v1/gen/document-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-schema.d.ts","sourceRoot":"","sources":["../../../../../document-models/pipeline-queue/v1/gen/document-schema.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAE9E,0EAA0E;AAC1E,eAAO,MAAM,iCAAiC;;;;;;iBAG1C,CAAC;AAEL,yEAAyE;AACzE,eAAO,MAAM,0BAA0B;;;;;;;;;iBAErC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAItC,CAAC;AAEH,iGAAiG;AACjG,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,oBAAoB,CAE/B;AAED,6GAA6G;AAC7G,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,KAAK,IAAI,oBAAoB,CAEvC;AAED,gFAAgF;AAChF,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,OAAO,GAChB,QAAQ,IAAI,qBAAqB,CAEnC;AAED,mFAAmF;AACnF,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,OAAO,GAChB,OAAO,CAAC,QAAQ,IAAI,qBAAqB,CAE3C"}

package/dist/document-models/pipeline-queue/v1/gen/document-schema.js

@@ -0,0 +1,33 @@
+import { BaseDocumentHeaderSchema, BaseDocumentStateSchema, } from "document-model";
+import { z } from "zod";
+import { pipelineQueueDocumentType } from "./document-type.js";
+import { PipelineQueueStateSchema } from "./schema/zod.js";
+/** Schema for validating the header object of a PipelineQueue document */
+export const PipelineQueueDocumentHeaderSchema = BaseDocumentHeaderSchema.extend({
+    documentType: z.literal(pipelineQueueDocumentType),
+});
+/** Schema for validating the state object of a PipelineQueue document */
+export const PipelineQueuePHStateSchema = BaseDocumentStateSchema.extend({
+    global: PipelineQueueStateSchema(),
+});
+export const PipelineQueueDocumentSchema = z.object({
+    header: PipelineQueueDocumentHeaderSchema,
+    state: PipelineQueuePHStateSchema,
+    initialState: PipelineQueuePHStateSchema,
+});
+/** Simple helper function to check if a state object is a PipelineQueue document state object */
+export function isPipelineQueueState(state) {
+    return PipelineQueuePHStateSchema.safeParse(state).success;
+}
+/** Simple helper function to assert that a document state object is a PipelineQueue document state object */
+export function assertIsPipelineQueueState(state) {
+    PipelineQueuePHStateSchema.parse(state);
+}
+/** Simple helper function to check if a document is a PipelineQueue document */
+export function isPipelineQueueDocument(document) {
+    return PipelineQueueDocumentSchema.safeParse(document).success;
+}
+/** Simple helper function to assert that a document is a PipelineQueue document */
+export function assertIsPipelineQueueDocument(document) {
+    PipelineQueueDocumentSchema.parse(document);
+}

package/dist/document-models/pipeline-queue/v1/gen/document-type.d.ts

@@ -0,0 +1,2 @@
+export declare const pipelineQueueDocumentType = "bai/pipeline-queue";
+//# sourceMappingURL=document-type.d.ts.map