@oisincoveney/pipeline 3.24.2 → 3.24.3

package/dist/tickets/backlog-task-store.js

@@ -1,13 +1,15 @@
-import { errorMessage, formatZodIssues } from "./validation-error-format.js";
+import { formatSchemaIssueList, mutableArray, parseResultWithSchema, struct, trimmedRequiredString, withDefault } from "../schema-boundary.js";
+import { errorMessage } from "./validation-error-format.js";
 import { RepoIoService } from "../runtime/services/repo-io-service.js";
 import { indexChildrenByParentId } from "./ticket-task-index.js";
-import { Data, Effect } from "effect";
-import { z } from "zod";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
 import { join } from "node:path";
+import * as Data from "effect/Data";
 import matter from "gray-matter";
 //#region src/tickets/backlog-task-store.ts
-const LINE_RE = /\r?\n/;
-const ACCEPTANCE_ITEM_RE = /^\s*-\s*\[[ xX]\]\s*(?:#?[\w.-]+\s+)?(.+)$/;
+const LINE_RE = /\r?\n/u;
+const ACCEPTANCE_ITEM_RE = /^\s*-\s*\[[ xX]\]\s*(?:#?[\w.-]+\s+)?(.+)$/u;
 const DESCRIPTION_MARKERS = {
 	end: "<!-- SECTION:DESCRIPTION:END -->",
 	start: "<!-- SECTION:DESCRIPTION:BEGIN -->"
@@ -16,69 +18,68 @@ const ACCEPTANCE_MARKERS = {
 	end: "<!-- AC:END -->",
 	start: "<!-- AC:BEGIN -->"
 };
-const nonEmptyStringSchema = z.string().trim().min(1);
-const taskFrontmatterSchema = z.object({
-	dependencies: z.array(nonEmptyStringSchema).default([]),
+const nonEmptyStringSchema = trimmedRequiredString;
+const taskFrontmatterSchema = struct({
+	dependencies: withDefault(mutableArray(nonEmptyStringSchema), []),
 	id: nonEmptyStringSchema,
-	modified_files: z.array(nonEmptyStringSchema).default([]),
-	ordinal: z.number().finite().optional(),
-	parent_task_id: nonEmptyStringSchema.optional(),
-	priority: z.enum([
+	modified_files: withDefault(mutableArray(nonEmptyStringSchema), []),
+	ordinal: Schema.optional(Schema.Number),
+	parent_task_id: Schema.optional(nonEmptyStringSchema),
+	priority: Schema.optional(Schema.Literals([
 		"high",
 		"medium",
 		"low"
-	]).optional(),
-	references: z.array(nonEmptyStringSchema).default([]),
-	status: z.enum([
+	])),
+	references: withDefault(mutableArray(nonEmptyStringSchema), []),
+	status: Schema.Literals([
 		"To Do",
 		"In Progress",
 		"Done"
 	]),
 	title: nonEmptyStringSchema
-}).passthrough();
+});
 var BacklogTaskStoreError = class extends Data.TaggedError("BacklogTaskStoreError") {};
-function loadBacklogTaskStoreEffect(worktreePath) {
-	return Effect.gen(function* () {
-		return yield* buildBacklogTaskStoreEffect(yield* readBacklogTasksEffect(worktreePath));
-	});
-}
-function parseBacklogTaskMarkdownEffect(source, filePath) {
-	return Effect.gen(function* () {
-		const parsed = yield* Effect.try({
-			catch: (error) => storeError(filePath, `Could not parse Backlog task frontmatter: ${errorMessage(error)}`),
-			try: () => matter(source)
-		});
-		return taskRecordFromDocument(yield* decodeFrontmatterEffect(parsed.data, filePath), parsed.content, filePath);
-	});
-}
-function readBacklogTasksEffect(worktreePath) {
-	const tasksDir = join(worktreePath, "backlog", "tasks");
-	return Effect.gen(function* () {
-		const repoIo = yield* RepoIoService;
-		if (!(yield* repoIo.exists(tasksDir).pipe(Effect.mapError((error) => ioStoreError(tasksDir, error))))) return [];
-		const entries = yield* repoIo.readDir(tasksDir).pipe(Effect.mapError((error) => ioStoreError(tasksDir, error)));
-		return yield* Effect.all(entries.filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => {
-			const filePath = join(tasksDir, entry.name);
-			return repoIo.readText(filePath).pipe(Effect.mapError((error) => ioStoreError(filePath, error)), Effect.flatMap((source) => parseBacklogTaskMarkdownEffect(source, filePath)));
-		}));
-	});
-}
-function decodeFrontmatterEffect(frontmatter, filePath) {
-	const decoded = taskFrontmatterSchema.safeParse(frontmatter);
-	if (decoded.success) return Effect.succeed(decoded.data);
-	return Effect.fail(storeError(filePath, `Invalid Backlog task frontmatter in ${filePath}: ${formatZodIssues(decoded.error.issues)}`));
-}
-function buildBacklogTaskStoreEffect(tasks) {
-	return Effect.gen(function* () {
-		const tasksById = yield* indexTasksByIdEffect(tasks);
-		return {
-			childrenByParentId: indexChildrenByParentId(tasks),
-			tasks,
-			tasksById
-		};
+const extractMarkedBlock = (content, markers) => {
+	const start = content.indexOf(markers.start);
+	if (start === -1) return "";
+	const bodyStart = start + markers.start.length;
+	const end = content.indexOf(markers.end, bodyStart);
+	if (end === -1) return "";
+	return content.slice(bodyStart, end).trim();
+};
+const extractDescription = (content) => extractMarkedBlock(content, DESCRIPTION_MARKERS);
+const extractAcceptanceCriteria = (content) => extractMarkedBlock(content, ACCEPTANCE_MARKERS).split(LINE_RE).map((line) => ACCEPTANCE_ITEM_RE.exec(line)?.[1]?.trim()).filter((criterion) => criterion !== void 0 && criterion.length > 0);
+const taskRecordFromDocument = (frontmatter, content, filePath) => ({
+	acceptanceCriteria: extractAcceptanceCriteria(content),
+	dependencies: frontmatter.dependencies,
+	description: extractDescription(content),
+	filePath,
+	id: frontmatter.id,
+	modifiedFiles: frontmatter.modified_files,
+	ordinal: frontmatter.ordinal,
+	parentTaskId: frontmatter.parent_task_id,
+	priority: frontmatter.priority,
+	references: frontmatter.references,
+	status: frontmatter.status,
+	title: frontmatter.title
+});
+const storeError = (path, message) => new BacklogTaskStoreError({
+	message,
+	path
+});
+const decodeFrontmatterEffect = (frontmatter, filePath) => {
+	const decoded = parseResultWithSchema(taskFrontmatterSchema, frontmatter, { onExcessProperty: "preserve" });
+	if (decoded.ok) return Effect.succeed(decoded.value);
+	return Effect.fail(storeError(filePath, `Invalid Backlog task frontmatter in ${filePath}: ${formatSchemaIssueList(decoded.issues)}`));
+};
+const parseBacklogTaskMarkdownEffect = (source, filePath) => Effect.gen(function* effectBody() {
+	const parsed = yield* Effect.try({
+		catch: (error) => storeError(filePath, `Could not parse Backlog task frontmatter: ${errorMessage(error)}`),
+		try: () => matter(source)
 	});
-}
-function indexTasksByIdEffect(tasks) {
+	return taskRecordFromDocument(yield* decodeFrontmatterEffect(parsed.data, filePath), parsed.content, filePath);
+});
+const indexTasksByIdEffect = (tasks) => {
 	const tasksById = /* @__PURE__ */ new Map();
 	for (const task of tasks) {
 		const existing = tasksById.get(task.id);
@@ -86,45 +87,30 @@ function indexTasksByIdEffect(tasks) {
 		tasksById.set(task.id, task);
 	}
 	return Effect.succeed(tasksById);
-}
-function taskRecordFromDocument(frontmatter, content, filePath) {
+};
+const buildBacklogTaskStoreEffect = (tasks) => Effect.gen(function* effectBody() {
+	const tasksById = yield* indexTasksByIdEffect(tasks);
 	return {
-		acceptanceCriteria: extractAcceptanceCriteria(content),
-		dependencies: frontmatter.dependencies,
-		description: extractDescription(content),
-		filePath,
-		id: frontmatter.id,
-		modifiedFiles: frontmatter.modified_files,
-		ordinal: frontmatter.ordinal,
-		parentTaskId: frontmatter.parent_task_id,
-		priority: frontmatter.priority,
-		references: frontmatter.references,
-		status: frontmatter.status,
-		title: frontmatter.title
+		childrenByParentId: indexChildrenByParentId(tasks),
+		tasks,
+		tasksById
 	};
-}
-function extractDescription(content) {
-	return extractMarkedBlock(content, DESCRIPTION_MARKERS);
-}
-function extractAcceptanceCriteria(content) {
-	return extractMarkedBlock(content, ACCEPTANCE_MARKERS).split(LINE_RE).map((line) => ACCEPTANCE_ITEM_RE.exec(line)?.[1]?.trim()).filter((criterion) => Boolean(criterion));
-}
-function extractMarkedBlock(content, markers) {
-	const start = content.indexOf(markers.start);
-	if (start < 0) return "";
-	const bodyStart = start + markers.start.length;
-	const end = content.indexOf(markers.end, bodyStart);
-	if (end < 0) return "";
-	return content.slice(bodyStart, end).trim();
-}
-function ioStoreError(path, error) {
-	return storeError(path, `Could not read Backlog task data: ${errorMessage(error)}`);
-}
-function storeError(path, message) {
-	return new BacklogTaskStoreError({
-		message,
-		path
+});
+const ioStoreError = (path, error) => storeError(path, `Could not read Backlog task data: ${errorMessage(error)}`);
+const readBacklogTasksEffect = (worktreePath) => {
+	const tasksDir = join(worktreePath, "backlog", "tasks");
+	return Effect.gen(function* effectBody() {
+		const repoIo = yield* RepoIoService;
+		if (!(yield* repoIo.exists(tasksDir).pipe(Effect.mapError((error) => ioStoreError(tasksDir, error))))) return [];
+		const entries = yield* repoIo.readDir(tasksDir).pipe(Effect.mapError((error) => ioStoreError(tasksDir, error)));
+		return yield* Effect.all(entries.filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => {
+			const filePath = join(tasksDir, entry.name);
+			return repoIo.readText(filePath).pipe(Effect.mapError((error) => ioStoreError(filePath, error)), Effect.flatMap((source) => parseBacklogTaskMarkdownEffect(source, filePath)));
+		}));
 	});
-}
+};
+const loadBacklogTaskStoreEffect = (worktreePath) => Effect.gen(function* effectBody() {
+	return yield* buildBacklogTaskStoreEffect(yield* readBacklogTasksEffect(worktreePath));
+});
 //#endregion
 export { BacklogTaskStoreError, loadBacklogTaskStoreEffect };

package/dist/tickets/completion/complete-ticket.js

@@ -24,61 +24,7 @@ const conservativeLayerAJudge = (input) => ({
 	rationale: `Layer A judge does not honor residue criterion '${input.criterion.id}' without anchored deterministic evidence`,
 	satisfied: false
 });
-/**
-* The keystone completion use-case (PIPE-90.11): load the ticket's acceptance
-* criteria, adjudicate the {@link CompletionClaim} through the layered gate, and
-* set the status to Done ONLY on a passing verdict. A refusal returns the
-* structured {@link UnmetCriterion}[] and performs no status write. Pure given
-* the injected store + judge.
-*/
-function completeTicket(input) {
-	return Effect.gen(function* () {
-		const target = yield* input.store.loadTarget(input.ticketId);
-		const verdict = yield* Effect.tryPromise({
-			catch: (error) => new TicketCompletionError({ message: `Adjudication failed for ticket '${input.ticketId}': ${errorMessage(error)}` }),
-			try: () => adjudicate({
-				claim: input.claim,
-				criteria: target.criteria,
-				deterministicGates: input.deterministicGates,
-				judge: input.judge
-			})
-		});
-		if (!verdict.passed) return {
-			status: "refused",
-			ticketId: input.ticketId,
-			unmet: verdict.unmet
-		};
-		yield* input.store.markDone(input.ticketId);
-		return {
-			status: "completed",
-			ticketId: input.ticketId
-		};
-	});
-}
-/**
-* Builds the live {@link TicketCompletionStore} backed by the Backlog task store
-* (read) and the `backlog` CLI (status write). Captures the worktree path and
-* the resolved services so the returned store's methods are service-free,
-* keeping {@link completeTicket} free of an R requirement.
-*/
-function backlogTicketCompletionStoreEffect(worktreePath) {
-	return Effect.gen(function* () {
-		const repoIo = yield* RepoIoService;
-		const backlog = yield* BacklogService;
-		return {
-			loadTarget: (ticketId) => loadBacklogTaskStoreEffect(worktreePath).pipe(Effect.provideService(RepoIoService, repoIo), Effect.mapError((error) => new TicketCompletionError({ message: error.message })), Effect.flatMap((store) => resolveTargetEffect(store, ticketId))),
-			markDone: (ticketId) => backlog.run([
-				"task",
-				"edit",
-				ticketId,
-				"--status",
-				"Done",
-				"--plain"
-			], worktreePath).pipe(Effect.asVoid, Effect.mapError((error) => new TicketCompletionError({ message: `Could not set ticket '${ticketId}' to Done: ${error.message}` })))
-		};
-	});
-}
-function resolveTargetEffect(store, ticketId) {
+const resolveTargetEffect = (store, ticketId) => {
 	const record = store.tasksById.get(ticketId);
 	if (!record) return Effect.fail(new TicketCompletionError({ message: `Unknown Backlog ticket '${ticketId}'` }));
 	return Effect.succeed({
@@ -88,9 +34,57 @@ function resolveTargetEffect(store, ticketId) {
 		})),
 		id: record.id
 	});
-}
-function errorMessage(error) {
-	return error instanceof Error ? error.message : String(error);
-}
+};
+/**
+* Builds the live {@link TicketCompletionStore} backed by the Backlog task store
+* (read) and the `backlog` CLI (status write). Captures the worktree path and
+* the resolved services so the returned store's methods are service-free,
+* keeping {@link completeTicket} free of an R requirement.
+*/
+const backlogTicketCompletionStoreEffect = (worktreePath) => Effect.gen(function* effectBody() {
+	const repoIo = yield* RepoIoService;
+	const backlog = yield* BacklogService;
+	return {
+		loadTarget: (ticketId) => loadBacklogTaskStoreEffect(worktreePath).pipe(Effect.provideService(RepoIoService, repoIo), Effect.mapError((error) => new TicketCompletionError({ message: error.message })), Effect.flatMap((store) => resolveTargetEffect(store, ticketId))),
+		markDone: (ticketId) => backlog.run([
+			"task",
+			"edit",
+			ticketId,
+			"--status",
+			"Done",
+			"--plain"
+		], worktreePath).pipe(Effect.asVoid, Effect.mapError((error) => new TicketCompletionError({ message: `Could not set ticket '${ticketId}' to Done: ${error.message}` })))
+	};
+});
+const errorMessage = (error) => error instanceof Error ? error.message : String(error);
+/**
+* The keystone completion use-case (PIPE-90.11): load the ticket's acceptance
+* criteria, adjudicate the {@link CompletionClaim} through the layered gate, and
+* set the status to Done ONLY on a passing verdict. A refusal returns the
+* structured {@link UnmetCriterion}[] and performs no status write. Pure given
+* the injected store + judge.
+*/
+const completeTicket = (input) => Effect.gen(function* effectBody() {
+	const target = yield* input.store.loadTarget(input.ticketId);
+	const verdict = yield* Effect.tryPromise({
+		catch: (error) => new TicketCompletionError({ message: `Adjudication failed for ticket '${input.ticketId}': ${errorMessage(error)}` }),
+		try: async () => await adjudicate({
+			claim: input.claim,
+			criteria: target.criteria,
+			deterministicGates: input.deterministicGates,
+			judge: input.judge
+		})
+	});
+	if (!verdict.passed) return {
+		status: "refused",
+		ticketId: input.ticketId,
+		unmet: verdict.unmet
+	};
+	yield* input.store.markDone(input.ticketId);
+	return {
+		status: "completed",
+		ticketId: input.ticketId
+	};
+});
 //#endregion
 export { TicketCompletionError, backlogTicketCompletionStoreEffect, completeTicket, conservativeLayerAJudge };

package/dist/tickets/ticket-graph-dto.d.ts

@@ -1,60 +1,37 @@
-import { TicketGraph } from "./ticket-graph.js";
-import { Effect } from "effect";
-import { z } from "zod";
+import { TicketGraph, TicketGraphError } from "./ticket-graph.js";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
 
 //#region src/tickets/ticket-graph-dto.d.ts
-/**
- * Node lifecycle in the loop controller DAG traversal.
- * One concept owns this variation — this enum is it.
- */
-declare const loopStateSchema: z.ZodEnum<{
-  blocked: "blocked";
-  merging: "merging";
-  passed: "passed";
-  queued: "queued";
-  running: "running";
+declare const LOOP_STATES: readonly ["queued", "running", "merging", "passed", "blocked"];
+declare const loopState: Schema.Literals<readonly ["queued", "running", "merging", "passed", "blocked"]>;
+type LoopState = typeof loopState.Type;
+declare const ticketGraphDto: Schema.Struct<{
+  readonly batches: Schema.mutable<Schema.$Array<Schema.mutable<Schema.$Array<Schema.NonEmptyString>>>>;
+  readonly dangling: Schema.mutable<Schema.$Array<Schema.String>>;
+  readonly edges: Schema.mutable<Schema.$Array<Schema.Struct<{
+    readonly from: Schema.NonEmptyString;
+    readonly to: Schema.NonEmptyString;
+  }>>>;
+  readonly nodes: Schema.mutable<Schema.$Array<Schema.Struct<{
+    readonly id: Schema.NonEmptyString;
+    readonly loopState: Schema.Literals<readonly ["queued", "running", "merging", "passed", "blocked"]>;
+    readonly priority: Schema.optional<Schema.Literals<readonly ["high", "medium", "low"]>>;
+    readonly status: Schema.Literals<readonly ["To Do", "In Progress", "Done"]>;
+    readonly title: Schema.NonEmptyString;
+  }>>>;
 }>;
-type LoopState = z.infer<typeof loopStateSchema>;
-declare const ticketGraphDtoSchema: z.ZodObject<{
-  batches: z.ZodArray<z.ZodArray<z.ZodString>>;
-  dangling: z.ZodArray<z.ZodString>;
-  edges: z.ZodArray<z.ZodObject<{
-    from: z.ZodString;
-    to: z.ZodString;
-  }, z.core.$strip>>;
-  nodes: z.ZodArray<z.ZodObject<{
-    id: z.ZodString;
-    loopState: z.ZodEnum<{
-      blocked: "blocked";
-      merging: "merging";
-      passed: "passed";
-      queued: "queued";
-      running: "running";
-    }>;
-    priority: z.ZodOptional<z.ZodEnum<{
-      high: "high";
-      low: "low";
-      medium: "medium";
-    }>>;
-    status: z.ZodEnum<{
-      Done: "Done";
-      "In Progress": "In Progress";
-      "To Do": "To Do";
-    }>;
-    title: z.ZodString;
-  }, z.core.$strip>>;
-}, z.core.$strip>;
-type TicketGraphDto = z.infer<typeof ticketGraphDtoSchema>;
+type TicketGraphDto = typeof ticketGraphDto.Type;
 /**
  * Convert a `TicketGraph` to the cross-repo wire DTO.
  *
  * All nodes default to `loopState: "queued"` — the controller updates
- * individual nodes via `loop.node.transition` events as work proceeds.
+ * individual nodes via `loop.node.transition` events while work proceeds.
  *
  * Returns an Effect because `sequenceTicketBatchesEffect` is effectful (it can
  * fail on a graph that cannot be topologically sorted, which should never
  * happen for a well-formed backlog but must be handled explicitly).
  */
-declare function serializeTicketGraph(graph: TicketGraph): Effect.Effect<TicketGraphDto, never>;
+declare const serializeTicketGraph: (graph: TicketGraph) => Effect.Effect<TicketGraphDto, TicketGraphError>;
 //#endregion
-export { LoopState, TicketGraphDto, loopStateSchema, serializeTicketGraph, ticketGraphDtoSchema };
+export { LOOP_STATES, LoopState, TicketGraphDto, loopState as loopStateSchema, serializeTicketGraph, ticketGraphDto as ticketGraphDtoSchema };

package/dist/tickets/ticket-graph-dto.js

@@ -1,73 +1,73 @@
 import { graphEdgeIds } from "../planning/graph.js";
+import { mutableArray, requiredString, struct } from "../schema-boundary.js";
 import { sequenceTicketBatchesEffect } from "./ticket-graph.js";
-import { Effect } from "effect";
-import { z } from "zod";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
 //#region src/tickets/ticket-graph-dto.ts
 /**
 * Node lifecycle in the loop controller DAG traversal.
 * One concept owns this variation — this enum is it.
 */
-const loopStateSchema = z.enum([
+const literalValues = (values) => values;
+const LOOP_STATES = literalValues([
 	"queued",
 	"running",
 	"merging",
 	"passed",
 	"blocked"
 ]);
-const ticketGraphDtoNodeSchema = z.object({
-	id: z.string().min(1),
-	loopState: loopStateSchema,
-	priority: z.enum([
+const loopState = Schema.Literals(LOOP_STATES);
+const ticketGraphDtoNode = struct({
+	id: requiredString,
+	loopState,
+	priority: Schema.optional(Schema.Literals([
 		"high",
 		"medium",
 		"low"
-	]).optional(),
-	status: z.enum([
+	])),
+	status: Schema.Literals([
 		"To Do",
 		"In Progress",
 		"Done"
 	]),
-	title: z.string().min(1)
+	title: requiredString
 });
-const ticketGraphDtoEdgeSchema = z.object({
-	from: z.string().min(1),
-	to: z.string().min(1)
+const ticketGraphDtoEdge = struct({
+	from: requiredString,
+	to: requiredString
 });
-const ticketGraphDtoSchema = z.object({
-	batches: z.array(z.array(z.string().min(1))),
-	dangling: z.array(z.string()),
-	edges: z.array(ticketGraphDtoEdgeSchema),
-	nodes: z.array(ticketGraphDtoNodeSchema)
+const ticketGraphDto = struct({
+	batches: mutableArray(mutableArray(requiredString)),
+	dangling: mutableArray(Schema.String),
+	edges: mutableArray(ticketGraphDtoEdge),
+	nodes: mutableArray(ticketGraphDtoNode)
 });
-const EMPTY_BATCHES = [];
 /**
 * Convert a `TicketGraph` to the cross-repo wire DTO.
 *
 * All nodes default to `loopState: "queued"` — the controller updates
-* individual nodes via `loop.node.transition` events as work proceeds.
+* individual nodes via `loop.node.transition` events while work proceeds.
 *
 * Returns an Effect because `sequenceTicketBatchesEffect` is effectful (it can
 * fail on a graph that cannot be topologically sorted, which should never
 * happen for a well-formed backlog but must be handled explicitly).
 */
-function serializeTicketGraph(graph) {
-	return Effect.gen(function* () {
-		const batches = yield* sequenceTicketBatchesEffect(graph).pipe(Effect.catch(() => Effect.succeed(EMPTY_BATCHES)));
-		const nodes = [...graph.tasksById.values()].map((task) => ({
-			id: task.id,
-			loopState: "queued",
-			...task.priority === void 0 ? {} : { priority: task.priority },
-			status: task.status,
-			title: task.title
-		}));
-		const edges = graphEdgeIds(graph.dependencyGraph);
-		return {
-			batches,
-			dangling: [...graph.danglingDependencies],
-			edges,
-			nodes
-		};
-	});
-}
+const serializeTicketGraph = (graph) => Effect.gen(function* effectBody() {
+	const batches = yield* sequenceTicketBatchesEffect(graph);
+	const nodes = [...graph.tasksById.values()].map((task) => ({
+		id: task.id,
+		loopState: "queued",
+		...task.priority === void 0 ? {} : { priority: task.priority },
+		status: task.status,
+		title: task.title
+	}));
+	const edges = graphEdgeIds(graph.dependencyGraph);
+	return {
+		batches,
+		dangling: [...graph.danglingDependencies],
+		edges,
+		nodes
+	};
+});
 //#endregion
-export { loopStateSchema, serializeTicketGraph, ticketGraphDtoSchema };
+export { LOOP_STATES, loopState as loopStateSchema, serializeTicketGraph, ticketGraphDto as ticketGraphDtoSchema };

package/dist/tickets/ticket-graph.d.ts

@@ -16,5 +16,11 @@ interface TicketGraph {
   readonly dependencyGraph: DependencyGraph<BacklogTaskRecord>;
   readonly tasksById: ReadonlyMap<string, BacklogTaskRecord>;
 }
+declare const TicketGraphError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "TicketGraphError";
+} & Readonly<A>;
+declare class TicketGraphError extends TicketGraphError_base<{
+  readonly message: string;
+}> {}
 //#endregion
-export { TicketGraph };
+export { TicketGraph, TicketGraphError };