import { n as __exportAll } from "./chunk-YKewjYmz.js";
import { A as array, F as object, I as string, M as lazy, N as literal, O as _enum, P as number, R as datetime, _ as defaultBaseState, a as BaseDocumentStateSchema, c as baseLoadFromInput, d as createAction, h as createState, i as BaseDocumentHeaderSchema, k as any, l as baseSaveToFileHandle, m as createReducer, o as baseActions, s as baseCreateDocument, y as isDocumentAction, z as generateId } from "./dist-DZj99xX4.js";
//#region document-models/pipeline-queue/v1/gen/schema/zod.ts
const isDefinedNonNullAny = (v) => v !== void 0 && v !== null;
const definedNonNullAnySchema = any().refine((v) => isDefinedNonNullAny(v));
const LearningCategorySchema = _enum([
	"FRICTION",
	"METHODOLOGY",
	"PROCESS_GAP",
	"SURPRISE"
]);
const TaskStatusSchema = _enum([
	"BLOCKED",
	"DONE",
	"FAILED",
	"IN_PROGRESS",
	"PENDING"
]);
function AddTaskInputSchema() {
	return object({
		batchId: string().nullish(),
		createdAt: datetime(),
		currentPhase: string().nullish(),
		documentRef: string().nullish(),
		id: string(),
		target: string(),
		taskType: string()
	});
}
function AdvancePhaseInputSchema() {
	return object({
		handoff: lazy(() => PhaseHandoffInputSchema()),
		taskId: string(),
		updatedAt: datetime()
	});
}
function AssignTaskInputSchema() {
	return object({
		assignedTo: string(),
		taskId: string(),
		updatedAt: datetime()
	});
}
function BlockTaskInputSchema() {
	return object({
		reason: string(),
		taskId: string(),
		updatedAt: datetime()
	});
}
function CompleteTaskInputSchema() {
	return object({
		taskId: string(),
		updatedAt: datetime()
	});
}
function FailTaskInputSchema() {
	return object({
		reason: string(),
		taskId: string(),
		updatedAt: datetime()
	});
}
function PhaseHandoffSchema() {
	return object({
		__typename: literal("PhaseHandoff").optional(),
		completedAt: datetime(),
		completedBy: string().nullish(),
		filesModified: array(string()),
		id: string(),
		learnings: array(lazy(() => PhaseLearningSchema())),
		phase: string(),
		workDone: string()
	});
}
function PhaseHandoffInputSchema() {
	return object({
		completedAt: datetime(),
		completedBy: string().nullish(),
		filesModified: array(string()),
		id: string(),
		phase: string(),
		workDone: string()
	});
}
function PhaseLearningSchema() {
	return object({
		__typename: literal("PhaseLearning").optional(),
		category: LearningCategorySchema,
		description: string(),
		id: string()
	});
}
function PhaseOrderEntrySchema() {
	return object({
		__typename: literal("PhaseOrderEntry").optional(),
		phases: array(string()),
		taskType: string()
	});
}
function PipelineQueueStateSchema() {
	return object({
		__typename: literal("PipelineQueueState").optional(),
		activeCount: number(),
		completedCount: number(),
		lastProcessedAt: datetime().nullish(),
		phaseOrder: array(lazy(() => PhaseOrderEntrySchema())),
		schemaVersion: number(),
		tasks: array(lazy(() => PipelineTaskSchema()))
	});
}
function PipelineTaskSchema() {
	return object({
		__typename: literal("PipelineTask").optional(),
		assignedTo: string().nullish(),
		batchId: string().nullish(),
		completedPhases: array(string()),
		createdAt: datetime(),
		currentPhase: string().nullish(),
		documentRef: string().nullish(),
		handoffs: array(lazy(() => PhaseHandoffSchema())),
		id: string(),
		status: TaskStatusSchema,
		target: string(),
		taskType: string(),
		updatedAt: datetime().nullish()
	});
}
function UnblockTaskInputSchema() {
	return object({
		taskId: string(),
		updatedAt: datetime()
	});
}
//#endregion
//#region document-models/pipeline-queue/v1/gen/queue-management/creators.ts
/**
* WARNING: DO NOT EDIT
* This file is auto-generated and updated by codegen
*/
var creators_exports = /* @__PURE__ */ __exportAll({
	addTask: () => addTask,
	advancePhase: () => advancePhase,
	assignTask: () => assignTask,
	blockTask: () => blockTask,
	completeTask: () => completeTask,
	failTask: () => failTask,
	unblockTask: () => unblockTask
});
const addTask = (input) => createAction("ADD_TASK", { ...input }, void 0, AddTaskInputSchema, "global");
const assignTask = (input) => createAction("ASSIGN_TASK", { ...input }, void 0, AssignTaskInputSchema, "global");
const advancePhase = (input) => createAction("ADVANCE_PHASE", { ...input }, void 0, AdvancePhaseInputSchema, "global");
const completeTask = (input) => createAction("COMPLETE_TASK", { ...input }, void 0, CompleteTaskInputSchema, "global");
const failTask = (input) => createAction("FAIL_TASK", { ...input }, void 0, FailTaskInputSchema, "global");
const blockTask = (input) => createAction("BLOCK_TASK", { ...input }, void 0, BlockTaskInputSchema, "global");
const unblockTask = (input) => createAction("UNBLOCK_TASK", { ...input }, void 0, UnblockTaskInputSchema, "global");
//#endregion
//#region document-models/pipeline-queue/v1/actions.ts
/**
* WARNING: DO NOT EDIT
* This file is auto-generated and updated by codegen
*/
/** Actions for the PipelineQueue document model */
const actions = {
	...baseActions,
	...creators_exports
};
//#endregion
//#region document-models/pipeline-queue/v1/gen/document-model.ts
const documentModel = {
	author: {
		name: "BAI",
		website: "https://bai.powerhouse.io/"
	},
	description: "Processing pipeline state — singleton document per vault tracking tasks through extract, connect, reweave, and verify phases with handoff protocol",
	extension: "",
	id: "bai/pipeline-queue",
	name: "PipelineQueue",
	specifications: [{
		changeLog: [],
		modules: [{
			description: "Pipeline task lifecycle and phase progression",
			id: "queue-management",
			name: "queue-management",
			operations: [
				{
					description: "Add a new task to the pipeline",
					errors: [],
					examples: [],
					id: "add-task",
					name: "ADD_TASK",
					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;",
					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",
					scope: "global"
				},
				{
					description: "Assign task to a processor or user",
					errors: [{
						code: "TASK_NOT_FOUND",
						description: "Task not found",
						id: "err-task-not-found-assign",
						name: "TaskNotFoundError",
						template: ""
					}],
					examples: [],
					id: "assign-task",
					name: "ASSIGN_TASK",
					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;",
					schema: "input AssignTaskInput {\n    taskId: OID!\n    assignedTo: String!\n    updatedAt: DateTime!\n}",
					template: "Assign task to a processor or user",
					scope: "global"
				},
				{
					description: "Complete current phase, advance to next",
					errors: [{
						code: "TASK_NOT_FOUND",
						description: "Task not found",
						id: "err-task-not-found-advance",
						name: "TaskNotFoundError",
						template: ""
					}],
					examples: [],
					id: "advance-phase",
					name: "ADVANCE_PHASE",
					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;",
					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",
					scope: "global"
				},
				{
					description: "Mark task as done",
					errors: [{
						code: "TASK_NOT_FOUND",
						description: "Task not found",
						id: "err-task-not-found-complete",
						name: "TaskNotFoundError",
						template: ""
					}],
					examples: [],
					id: "complete-task",
					name: "COMPLETE_TASK",
					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;",
					schema: "input CompleteTaskInput {\n    taskId: OID!\n    updatedAt: DateTime!\n}",
					template: "Mark task as done",
					scope: "global"
				},
				{
					description: "Mark task as failed",
					errors: [{
						code: "TASK_NOT_FOUND",
						description: "Task not found",
						id: "err-task-not-found-fail",
						name: "TaskNotFoundError",
						template: ""
					}],
					examples: [],
					id: "fail-task",
					name: "FAIL_TASK",
					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;",
					schema: "input FailTaskInput {\n    taskId: OID!\n    reason: String!\n    updatedAt: DateTime!\n}",
					template: "Mark task as failed",
					scope: "global"
				},
				{
					description: "Mark task as blocked",
					errors: [{
						code: "TASK_NOT_FOUND",
						description: "Task not found",
						id: "err-task-not-found-block",
						name: "TaskNotFoundError",
						template: ""
					}],
					examples: [],
					id: "block-task",
					name: "BLOCK_TASK",
					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;",
					schema: "input BlockTaskInput {\n    taskId: OID!\n    reason: String!\n    updatedAt: DateTime!\n}",
					template: "Mark task as blocked",
					scope: "global"
				},
				{
					description: "Unblock a task",
					errors: [{
						code: "TASK_NOT_FOUND",
						description: "Task not found",
						id: "err-task-not-found-unblock",
						name: "TaskNotFoundError",
						template: ""
					}, {
						code: "INVALID_TASK_STATUS",
						description: "Task is not in the expected status",
						id: "err-invalid-task-status",
						name: "InvalidTaskStatusError",
						template: ""
					}],
					examples: [],
					id: "unblock-task",
					name: "UNBLOCK_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;",
					schema: "input UnblockTaskInput {\n    taskId: OID!\n    updatedAt: DateTime!\n}",
					template: "Unblock a task",
					scope: "global"
				}
			]
		}],
		state: {
			global: {
				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}",
				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}"
			},
			local: {
				examples: [],
				initialValue: "",
				schema: ""
			}
		},
		version: 1
	}]
};
//#endregion
//#region document-models/pipeline-queue/v1/gen/queue-management/error.ts
var TaskNotFoundError = class extends Error {
	errorCode = "TaskNotFoundError";
	constructor(message = "TaskNotFoundError") {
		super(message);
	}
};
var InvalidTaskStatusError = class extends Error {
	errorCode = "InvalidTaskStatusError";
	constructor(message = "InvalidTaskStatusError") {
		super(message);
	}
};
//#endregion
//#region document-models/pipeline-queue/v1/src/reducers/queue-management.ts
const pipelineQueueQueueManagementOperations = {
	addTaskOperation(state, action) {
		const phaseEntry = state.phaseOrder.find((p) => p.taskType === action.input.taskType);
		const firstPhase = action.input.currentPhase || (phaseEntry ? phaseEntry.phases[0] : null);
		state.tasks.push({
			id: action.input.id,
			taskType: action.input.taskType,
			status: "PENDING",
			target: action.input.target,
			batchId: action.input.batchId || null,
			documentRef: action.input.documentRef || null,
			currentPhase: firstPhase || null,
			completedPhases: [],
			handoffs: [],
			assignedTo: null,
			createdAt: action.input.createdAt,
			updatedAt: null
		});
		state.activeCount = (state.activeCount || 0) + 1;
	},
	assignTaskOperation(state, action) {
		const task = state.tasks.find((t) => t.id === action.input.taskId);
		if (!task) throw new TaskNotFoundError("Task not found");
		task.assignedTo = action.input.assignedTo;
		task.status = "IN_PROGRESS";
		task.updatedAt = action.input.updatedAt;
		state.lastProcessedAt = action.input.updatedAt;
	},
	advancePhaseOperation(state, action) {
		const task = state.tasks.find((t) => t.id === action.input.taskId);
		if (!task) throw new TaskNotFoundError("Task not found");
		const handoff = action.input.handoff;
		task.handoffs.push({
			id: handoff.id,
			phase: handoff.phase,
			workDone: handoff.workDone,
			filesModified: handoff.filesModified,
			learnings: [],
			completedAt: handoff.completedAt,
			completedBy: handoff.completedBy || null
		});
		if (task.currentPhase) task.completedPhases.push(task.currentPhase);
		const phaseEntry = state.phaseOrder.find((p) => p.taskType === task.taskType);
		if (phaseEntry) {
			const currentIdx = phaseEntry.phases.indexOf(task.currentPhase || "");
			const nextPhase = phaseEntry.phases[currentIdx + 1];
			if (nextPhase) {
				task.currentPhase = nextPhase;
				task.status = "PENDING";
			} else {
				task.currentPhase = null;
				task.status = "DONE";
				state.completedCount = (state.completedCount || 0) + 1;
				state.activeCount = Math.max(0, (state.activeCount || 0) - 1);
			}
		}
		task.assignedTo = null;
		task.updatedAt = action.input.updatedAt;
		state.lastProcessedAt = action.input.updatedAt;
	},
	completeTaskOperation(state, action) {
		const task = state.tasks.find((t) => t.id === action.input.taskId);
		if (!task) throw new TaskNotFoundError("Task not found");
		task.status = "DONE";
		task.currentPhase = null;
		task.updatedAt = action.input.updatedAt;
		state.completedCount = (state.completedCount || 0) + 1;
		state.activeCount = Math.max(0, (state.activeCount || 0) - 1);
		state.lastProcessedAt = action.input.updatedAt;
	},
	failTaskOperation(state, action) {
		const task = state.tasks.find((t) => t.id === action.input.taskId);
		if (!task) throw new TaskNotFoundError("Task not found");
		task.status = "FAILED";
		task.updatedAt = action.input.updatedAt;
		state.activeCount = Math.max(0, (state.activeCount || 0) - 1);
		state.lastProcessedAt = action.input.updatedAt;
	},
	blockTaskOperation(state, action) {
		const task = state.tasks.find((t) => t.id === action.input.taskId);
		if (!task) throw new TaskNotFoundError("Task not found");
		task.status = "BLOCKED";
		task.updatedAt = action.input.updatedAt;
	},
	unblockTaskOperation(state, action) {
		const task = state.tasks.find((t) => t.id === action.input.taskId);
		if (!task) throw new TaskNotFoundError("Task not found");
		if (task.status !== "BLOCKED") throw new InvalidTaskStatusError("Task is not blocked");
		task.status = "PENDING";
		task.updatedAt = action.input.updatedAt;
	}
};
//#endregion
//#region document-models/pipeline-queue/v1/gen/reducer.ts
const stateReducer = (state, action, dispatch) => {
	if (isDocumentAction(action)) return state;
	switch (action.type) {
		case "ADD_TASK":
			AddTaskInputSchema().parse(action.input);
			pipelineQueueQueueManagementOperations.addTaskOperation(state[action.scope], action, dispatch);
			break;
		case "ASSIGN_TASK":
			AssignTaskInputSchema().parse(action.input);
			pipelineQueueQueueManagementOperations.assignTaskOperation(state[action.scope], action, dispatch);
			break;
		case "ADVANCE_PHASE":
			AdvancePhaseInputSchema().parse(action.input);
			pipelineQueueQueueManagementOperations.advancePhaseOperation(state[action.scope], action, dispatch);
			break;
		case "COMPLETE_TASK":
			CompleteTaskInputSchema().parse(action.input);
			pipelineQueueQueueManagementOperations.completeTaskOperation(state[action.scope], action, dispatch);
			break;
		case "FAIL_TASK":
			FailTaskInputSchema().parse(action.input);
			pipelineQueueQueueManagementOperations.failTaskOperation(state[action.scope], action, dispatch);
			break;
		case "BLOCK_TASK":
			BlockTaskInputSchema().parse(action.input);
			pipelineQueueQueueManagementOperations.blockTaskOperation(state[action.scope], action, dispatch);
			break;
		case "UNBLOCK_TASK":
			UnblockTaskInputSchema().parse(action.input);
			pipelineQueueQueueManagementOperations.unblockTaskOperation(state[action.scope], action, dispatch);
			break;
		default: return state;
	}
};
const reducer = createReducer(stateReducer);
//#endregion
//#region document-models/pipeline-queue/v1/gen/document-type.ts
/**
* WARNING: DO NOT EDIT
* This file is auto-generated and updated by codegen
*/
const pipelineQueueDocumentType = "bai/pipeline-queue";
//#endregion
//#region document-models/pipeline-queue/v1/gen/document-schema.ts
/**
* WARNING: DO NOT EDIT
* This file is auto-generated and updated by codegen
*/
/** Schema for validating the header object of a PipelineQueue document */
const PipelineQueueDocumentHeaderSchema = BaseDocumentHeaderSchema.extend({ documentType: literal(pipelineQueueDocumentType) });
/** Schema for validating the state object of a PipelineQueue document */
const PipelineQueuePHStateSchema = BaseDocumentStateSchema.extend({ global: PipelineQueueStateSchema() });
const PipelineQueueDocumentSchema = object({
	header: PipelineQueueDocumentHeaderSchema,
	state: PipelineQueuePHStateSchema,
	initialState: PipelineQueuePHStateSchema
});
/** Simple helper function to check if a state object is a PipelineQueue document state object */
function isPipelineQueueState(state) {
	return PipelineQueuePHStateSchema.safeParse(state).success;
}
/** Simple helper function to assert that a document state object is a PipelineQueue document state object */
function assertIsPipelineQueueState(state) {
	PipelineQueuePHStateSchema.parse(state);
}
/** Simple helper function to check if a document is a PipelineQueue document */
function isPipelineQueueDocument(document) {
	return PipelineQueueDocumentSchema.safeParse(document).success;
}
/** Simple helper function to assert that a document is a PipelineQueue document */
function assertIsPipelineQueueDocument(document) {
	PipelineQueueDocumentSchema.parse(document);
}
//#endregion
//#region document-models/pipeline-queue/v1/gen/utils.ts
const initialGlobalState = {
	schemaVersion: 3,
	phaseOrder: [{
		taskType: "claim",
		phases: [
			"create",
			"reflect",
			"reweave",
			"verify"
		]
	}, {
		taskType: "enrichment",
		phases: [
			"enrich",
			"reflect",
			"reweave",
			"verify"
		]
	}],
	tasks: [],
	completedCount: 0,
	activeCount: 0,
	lastProcessedAt: null
};
const initialLocalState = {};
const utils$1 = {
	fileExtension: "",
	createState(state) {
		return {
			...defaultBaseState(),
			global: {
				...initialGlobalState,
				...state?.global
			},
			local: {
				...initialLocalState,
				...state?.local
			}
		};
	},
	createDocument(state) {
		const document = baseCreateDocument(utils$1.createState, state);
		document.header.documentType = pipelineQueueDocumentType;
		document.header.id = generateId();
		return document;
	},
	saveToFileHandle(document, input) {
		return baseSaveToFileHandle(document, input);
	},
	loadFromInput(input) {
		return baseLoadFromInput(input, reducer);
	},
	isStateOfType(state) {
		return isPipelineQueueState(state);
	},
	assertIsStateOfType(state) {
		return assertIsPipelineQueueState(state);
	},
	isDocumentOfType(document) {
		return isPipelineQueueDocument(document);
	},
	assertIsDocumentOfType(document) {
		return assertIsPipelineQueueDocument(document);
	}
};
//#endregion
//#region document-models/pipeline-queue/v1/src/utils.ts
var utils_exports = /* @__PURE__ */ __exportAll({});
//#endregion
//#region document-models/pipeline-queue/v1/utils.ts
/** Utils for the PipelineQueue document model */
const utils = {
	...utils$1,
	...utils_exports
};
//#endregion
//#region document-models/pipeline-queue/v1/module.ts
/** Document model module for the PipelineQueue document type */
const PipelineQueue = {
	version: 1,
	reducer,
	actions,
	utils,
	documentModel: createState(defaultBaseState(), documentModel)
};
//#endregion
export { FailTaskInputSchema as A, definedNonNullAnySchema as B, failTask as C, AssignTaskInputSchema as D, AdvancePhaseInputSchema as E, PhaseOrderEntrySchema as F, PipelineQueueStateSchema as I, PipelineTaskSchema as L, PhaseHandoffInputSchema as M, PhaseHandoffSchema as N, BlockTaskInputSchema as O, PhaseLearningSchema as P, TaskStatusSchema as R, creators_exports as S, AddTaskInputSchema as T, isDefinedNonNullAny as V, addTask as _, utils$1 as a, blockTask as b, PipelineQueuePHStateSchema as c, isPipelineQueueDocument as d, isPipelineQueueState as f, actions as g, documentModel as h, initialLocalState as i, LearningCategorySchema as j, CompleteTaskInputSchema as k, assertIsPipelineQueueDocument as l, reducer as m, utils as n, PipelineQueueDocumentHeaderSchema as o, pipelineQueueDocumentType as p, initialGlobalState as r, PipelineQueueDocumentSchema as s, PipelineQueue as t, assertIsPipelineQueueState as u, advancePhase as v, unblockTask as w, completeTask as x, assignTask as y, UnblockTaskInputSchema as z };

//# sourceMappingURL=module-B5NYs6Iy.js.map