toolcraft 0.0.2 → 0.0.4

package/node_modules/@poe-code/task-list/dist/backends/yaml-file.js

@@ -0,0 +1,444 @@
+import { acquireFileLock } from "@poe-code/file-lock";
+import { parseDocument } from "yaml";
+import storeSchema from "../schema/store.schema.json" with { type: "json" };
+import taskSchema from "../schema/task.schema.json" with { type: "json" };
+import { eventsFromState, findEvent } from "../state-machine.js";
+import { resolveStateMachine } from "../state.js";
+import { InvalidTransitionError, MalformedTaskError, TaskAlreadyExistsError, TaskNotFoundError } from "../types.js";
+import { isRecord, sortStrings, sortTasks, statIfExists, validateTaskId, writeAtomically } from "./utils.js";
+const STORE_KIND = "task-store";
+const STORE_SCHEMA_ID = storeSchema.$id;
+const STORE_VERSION = 1;
+const TASK_KIND = "task";
+const TASK_SCHEMA_ID = taskSchema.$id;
+const TASK_VERSION = 1;
+const RESERVED_TASK_KEYS = new Set(["$schema", "description", "kind", "name", "state", "version"]);
+function malformedStore(filePath, field) {
+    return new MalformedTaskError(`Malformed task store "${filePath}": invalid "${field}".`);
+}
+function malformedTask(list, id, field) {
+    return new MalformedTaskError(`Malformed task "${list}/${id}": invalid "${field}".`);
+}
+function validateListName(name) {
+    if (name.length === 0 ||
+        name.startsWith(".") ||
+        name.includes("/") ||
+        name.includes("\\") ||
+        name.includes("..")) {
+        throw new Error(`Invalid task list name "${name}".`);
+    }
+    return name;
+}
+function parseQualifiedId(qualifiedId) {
+    const separatorIndex = qualifiedId.indexOf("/");
+    if (separatorIndex <= 0 ||
+        separatorIndex !== qualifiedId.lastIndexOf("/") ||
+        separatorIndex === qualifiedId.length - 1) {
+        throw new Error(`Invalid qualified task id "${qualifiedId}".`);
+    }
+    return {
+        list: validateListName(qualifiedId.slice(0, separatorIndex)),
+        id: validateTaskId(qualifiedId.slice(separatorIndex + 1))
+    };
+}
+function descriptionFromTaskRecord(taskRecord) {
+    return typeof taskRecord.description === "string" ? taskRecord.description : "";
+}
+function metadataFromTaskRecord(taskRecord) {
+    const metadata = {};
+    for (const [key, value] of Object.entries(taskRecord)) {
+        if (!RESERVED_TASK_KEYS.has(key)) {
+            metadata[key] = value;
+        }
+    }
+    return metadata;
+}
+function createTask(list, id, taskRecord) {
+    return {
+        list,
+        id,
+        qualifiedId: `${list}/${id}`,
+        name: taskRecord.name,
+        state: taskRecord.state,
+        description: descriptionFromTaskRecord(taskRecord),
+        metadata: metadataFromTaskRecord(taskRecord)
+    };
+}
+function matchesFilter(task, filter) {
+    if (!filter?.includeArchived && task.state === "archived") {
+        return false;
+    }
+    if (filter?.state !== undefined && task.state !== filter.state) {
+        return false;
+    }
+    return true;
+}
+function createTaskRecord(defaults, input, initialState) {
+    const taskRecord = {
+        name: input.name,
+        state: initialState,
+        description: input.description ?? ""
+    };
+    for (const [key, value] of Object.entries(defaults.metadata)) {
+        if (!RESERVED_TASK_KEYS.has(key)) {
+            taskRecord[key] = value;
+        }
+    }
+    for (const [key, value] of Object.entries(input.metadata ?? {})) {
+        if (!RESERVED_TASK_KEYS.has(key)) {
+            taskRecord[key] = value;
+        }
+    }
+    return taskRecord;
+}
+function assertCreateDoesNotSetState(input) {
+    if (Object.prototype.hasOwnProperty.call(input, "state")) {
+        throw new Error('Tasks.create() does not accept "state"; new tasks always start at stateMachine.initial.');
+    }
+}
+function assertUpdateDoesNotSetState(patch) {
+    if (Object.prototype.hasOwnProperty.call(patch, "state")) {
+        throw new Error('Tasks.update() does not accept "state"; use fire() to change task state.');
+    }
+}
+function buildUpdatedTaskRecord(existing, patch) {
+    const nextTaskRecord = {
+        ...existing,
+        name: patch.name ?? existing.name,
+        state: existing.state,
+        description: patch.description ?? descriptionFromTaskRecord(existing)
+    };
+    for (const [key, value] of Object.entries(patch.metadata ?? {})) {
+        if (!RESERVED_TASK_KEYS.has(key)) {
+            nextTaskRecord[key] = value;
+        }
+    }
+    return nextTaskRecord;
+}
+function buildTransitionedTaskRecord(existing, to) {
+    return {
+        ...existing,
+        state: to,
+        description: descriptionFromTaskRecord(existing)
+    };
+}
+function buildFiredTaskRecord(existing, to, metadataPatch) {
+    const nextTaskRecord = buildTransitionedTaskRecord(existing, to);
+    for (const [key, value] of Object.entries(metadataPatch ?? {})) {
+        if (!RESERVED_TASK_KEYS.has(key)) {
+            nextTaskRecord[key] = value;
+        }
+    }
+    return nextTaskRecord;
+}
+function parseStoreDocument(filePath, content) {
+    let document;
+    try {
+        document = parseDocument(content, { keepSourceTokens: true, prettyErrors: false });
+    }
+    catch {
+        throw malformedStore(filePath, "yaml");
+    }
+    if (document.errors.length > 0) {
+        throw malformedStore(filePath, "yaml");
+    }
+    return document;
+}
+function assertValidStoreRecord(store, filePath) {
+    if (!isRecord(store)) {
+        throw malformedStore(filePath, "store");
+    }
+    if (store.$schema !== STORE_SCHEMA_ID) {
+        throw malformedStore(filePath, "$schema");
+    }
+    if (store.kind !== STORE_KIND) {
+        throw malformedStore(filePath, "kind");
+    }
+    if (typeof store.version !== "number" || !Number.isInteger(store.version) || store.version !== STORE_VERSION) {
+        throw malformedStore(filePath, "version");
+    }
+    if (!isRecord(store.lists)) {
+        throw malformedStore(filePath, "lists");
+    }
+}
+function assertValidTaskRecord(taskRecord, list, id, validStates) {
+    if (!isRecord(taskRecord)) {
+        throw malformedTask(list, id, "task");
+    }
+    if ("$schema" in taskRecord && taskRecord.$schema !== TASK_SCHEMA_ID) {
+        throw malformedTask(list, id, "$schema");
+    }
+    if ("kind" in taskRecord && taskRecord.kind !== TASK_KIND) {
+        throw malformedTask(list, id, "kind");
+    }
+    if ("version" in taskRecord) {
+        if (typeof taskRecord.version !== "number" ||
+            !Number.isInteger(taskRecord.version) ||
+            taskRecord.version !== TASK_VERSION) {
+            throw malformedTask(list, id, "version");
+        }
+    }
+    if (typeof taskRecord.name !== "string" || taskRecord.name.length === 0) {
+        throw malformedTask(list, id, "name");
+    }
+    if (typeof taskRecord.state !== "string" || !validStates.has(taskRecord.state)) {
+        throw malformedTask(list, id, "state");
+    }
+    if ("description" in taskRecord && typeof taskRecord.description !== "string") {
+        throw malformedTask(list, id, "description");
+    }
+}
+function validateStoreEntries(store, filePath, validStates) {
+    const lists = store.lists;
+    if (!isRecord(lists)) {
+        throw malformedStore(filePath, "lists");
+    }
+    for (const [list, listRecord] of Object.entries(lists)) {
+        try {
+            validateListName(list);
+        }
+        catch {
+            throw malformedStore(filePath, `lists.${list}`);
+        }
+        if (!isRecord(listRecord)) {
+            throw malformedStore(filePath, `lists.${list}`);
+        }
+        for (const [id, taskRecord] of Object.entries(listRecord)) {
+            try {
+                validateTaskId(id);
+            }
+            catch {
+                throw malformedTask(list, id, "id");
+            }
+            assertValidTaskRecord(taskRecord, list, id, validStates);
+        }
+    }
+}
+function serializeDocument(document) {
+    const serialized = document.toString();
+    return serialized.endsWith("\n") ? serialized : `${serialized}\n`;
+}
+async function readStore(fs, filePath, validStates) {
+    const content = await fs.readFile(filePath, "utf8");
+    const document = parseStoreDocument(filePath, content);
+    const store = document.toJS();
+    assertValidStoreRecord(store, filePath);
+    validateStoreEntries(store, filePath, validStates);
+    return {
+        document,
+        store
+    };
+}
+function getListsRecord(store) {
+    return store.lists;
+}
+function getListRecord(store, list) {
+    const listRecord = getListsRecord(store)[list];
+    return isRecord(listRecord) ? listRecord : undefined;
+}
+function getTaskRecord(store, list, id) {
+    const listRecord = getListRecord(store, list);
+    const taskRecord = listRecord?.[id];
+    return isRecord(taskRecord) ? taskRecord : undefined;
+}
+function getTaskOrThrow(store, list, id) {
+    const taskRecord = getTaskRecord(store, list, id);
+    if (!taskRecord) {
+        throw new TaskNotFoundError(`Task "${list}/${id}" not found.`);
+    }
+    return taskRecord;
+}
+async function ensureStorePath(deps) {
+    if (!deps.create) {
+        await deps.fs.stat(deps.path);
+        return;
+    }
+    const existing = await statIfExists(deps.fs, deps.path);
+    if (existing !== undefined) {
+        return;
+    }
+    await writeAtomically(deps.fs, deps.path, serializeDocument(parseDocument([
+        `$schema: ${STORE_SCHEMA_ID}`,
+        `kind: ${STORE_KIND}`,
+        `version: ${STORE_VERSION}`,
+        "lists: {}",
+        ""
+    ].join("\n"))));
+}
+async function withStoreLock(deps, action) {
+    const release = await acquireFileLock(deps.path, {
+        fs: deps.fs,
+        staleMs: deps.lockStaleMs,
+        retries: deps.lockRetries
+    });
+    try {
+        return await action();
+    }
+    finally {
+        await release();
+    }
+}
+function createTasksView(deps, list) {
+    const stateMachine = resolveStateMachine(deps.stateMachine);
+    const validStates = new Set(stateMachine.states);
+    async function readTasks(filter) {
+        const { store } = await readStore(deps.fs, deps.path, validStates);
+        const listRecord = getListRecord(store, list);
+        if (!listRecord) {
+            return [];
+        }
+        const tasks = Object.entries(listRecord).map(([id, taskRecord]) => createTask(list, id, taskRecord));
+        return sortTasks(tasks.filter((task) => matchesFilter(task, filter)));
+    }
+    function assertFireableTaskEvent(task, eventName) {
+        const event = findEvent(stateMachine, task.state, eventName);
+        if (event === undefined) {
+            throw new InvalidTransitionError({
+                task,
+                event: eventName,
+                to: stateMachine.events[eventName]?.to,
+                reason: `Cannot fire event "${eventName}" from task state "${task.state}".`
+            });
+        }
+        return event;
+    }
+    return {
+        name: list,
+        stateMachine,
+        async all(filter) {
+            return readTasks(filter);
+        },
+        async get(id) {
+            validateTaskId(id);
+            const { store } = await readStore(deps.fs, deps.path, validStates);
+            return createTask(list, id, getTaskOrThrow(store, list, id));
+        },
+        async create(input) {
+            assertCreateDoesNotSetState(input);
+            validateTaskId(input.id);
+            return withStoreLock(deps, async () => {
+                const { document, store } = await readStore(deps.fs, deps.path, validStates);
+                if (getTaskRecord(store, list, input.id)) {
+                    throw new TaskAlreadyExistsError(`Task "${list}/${input.id}" already exists.`);
+                }
+                const taskRecord = createTaskRecord(deps.defaults, input, stateMachine.initial);
+                document.setIn(["lists", list, input.id], taskRecord);
+                await writeAtomically(deps.fs, deps.path, serializeDocument(document));
+                return createTask(list, input.id, taskRecord);
+            });
+        },
+        async update(id, patch) {
+            assertUpdateDoesNotSetState(patch);
+            validateTaskId(id);
+            return withStoreLock(deps, async () => {
+                const { document, store } = await readStore(deps.fs, deps.path, validStates);
+                const existing = getTaskOrThrow(store, list, id);
+                const nextTaskRecord = buildUpdatedTaskRecord(existing, patch);
+                if (patch.name !== undefined) {
+                    document.setIn(["lists", list, id, "name"], patch.name);
+                }
+                if (patch.description !== undefined) {
+                    document.setIn(["lists", list, id, "description"], patch.description);
+                }
+                for (const [key, value] of Object.entries(patch.metadata ?? {})) {
+                    if (!RESERVED_TASK_KEYS.has(key)) {
+                        document.setIn(["lists", list, id, key], value);
+                    }
+                }
+                await writeAtomically(deps.fs, deps.path, serializeDocument(document));
+                return createTask(list, id, nextTaskRecord);
+            });
+        },
+        async fire(id, eventName, opts) {
+            validateTaskId(id);
+            return withStoreLock(deps, async () => {
+                const { document, store } = await readStore(deps.fs, deps.path, validStates);
+                const existing = getTaskOrThrow(store, list, id);
+                const task = createTask(list, id, existing);
+                const event = assertFireableTaskEvent(task, eventName);
+                const guardResult = event.guard?.(task) ?? true;
+                if (guardResult !== true) {
+                    throw new InvalidTransitionError({
+                        task,
+                        event: eventName,
+                        to: event.to,
+                        reason: guardResult
+                    });
+                }
+                await event.onExit?.(task);
+                const nextTaskRecord = buildFiredTaskRecord(existing, event.to, opts?.metadataPatch);
+                document.setIn(["lists", list, id, "state"], event.to);
+                for (const [key, value] of Object.entries(opts?.metadataPatch ?? {})) {
+                    if (!RESERVED_TASK_KEYS.has(key)) {
+                        document.setIn(["lists", list, id, key], value);
+                    }
+                }
+                await writeAtomically(deps.fs, deps.path, serializeDocument(document));
+                const nextTask = createTask(list, id, nextTaskRecord);
+                await event.onEnter?.(nextTask);
+                return nextTask;
+            });
+        },
+        async canFire(id, eventName) {
+            validateTaskId(id);
+            const { store } = await readStore(deps.fs, deps.path, validStates);
+            const task = createTask(list, id, getTaskOrThrow(store, list, id));
+            const event = findEvent(stateMachine, task.state, eventName);
+            if (event === undefined) {
+                return false;
+            }
+            return (event.guard?.(task) ?? true) === true;
+        },
+        async events(id) {
+            validateTaskId(id);
+            const { store } = await readStore(deps.fs, deps.path, validStates);
+            const task = createTask(list, id, getTaskOrThrow(store, list, id));
+            return eventsFromState(stateMachine, task.state);
+        },
+        async delete(id) {
+            validateTaskId(id);
+            await withStoreLock(deps, async () => {
+                const { document, store } = await readStore(deps.fs, deps.path, validStates);
+                getTaskOrThrow(store, list, id);
+                document.deleteIn(["lists", list, id]);
+                await writeAtomically(deps.fs, deps.path, serializeDocument(document));
+            });
+        }
+    };
+}
+export async function yamlFileBackend(deps) {
+    await ensureStorePath(deps);
+    const stateMachine = resolveStateMachine(deps.stateMachine);
+    const validStates = new Set(stateMachine.states);
+    const list = (name) => {
+        const listName = validateListName(name);
+        return createTasksView({ ...deps, stateMachine }, listName);
+    };
+    const lists = async () => {
+        const { store } = await readStore(deps.fs, deps.path, validStates);
+        return sortStrings(Object.keys(getListsRecord(store)));
+    };
+    const allTasks = async (filter) => {
+        const { store } = await readStore(deps.fs, deps.path, validStates);
+        const tasks = [];
+        for (const [listName, listRecord] of Object.entries(getListsRecord(store))) {
+            for (const [id, taskRecord] of Object.entries(listRecord)) {
+                const task = createTask(listName, id, taskRecord);
+                if (matchesFilter(task, filter)) {
+                    tasks.push(task);
+                }
+            }
+        }
+        return sortTasks(tasks);
+    };
+    const get = async (qualifiedId) => {
+        const { list: listName, id } = parseQualifiedId(qualifiedId);
+        return list(listName).get(id);
+    };
+    return {
+        list,
+        lists,
+        allTasks,
+        get
+    };
+}

package/node_modules/@poe-code/task-list/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { openTaskList } from "./open.js";
+export { assertEvent, assertTransition, defaultStateMachine, type TaskEvent } from "./state.js";
+export { eventsFromState, findEvent, validateMachine, type EventDef, type StateMachineDef } from "./state-machine.js";
+export { InvalidTransitionError, MalformedTaskError, TaskAlreadyExistsError, TaskNotFoundError, type ListFilter, type OpenTaskListOptions, type Task, type TaskCreate, type TaskDefaults, type TaskFireOptions, type TaskList, type TaskListFs, type TaskState, type Tasks, type TaskUpdate } from "./types.js";

package/node_modules/@poe-code/task-list/dist/index.js

@@ -0,0 +1,4 @@
+export { openTaskList } from "./open.js";
+export { assertEvent, assertTransition, defaultStateMachine } from "./state.js";
+export { eventsFromState, findEvent, validateMachine } from "./state-machine.js";
+export { InvalidTransitionError, MalformedTaskError, TaskAlreadyExistsError, TaskNotFoundError } from "./types.js";

package/node_modules/@poe-code/task-list/dist/open.d.ts

@@ -0,0 +1,3 @@
+import type { BackendFactory, OpenTaskListOptions, TaskList } from "./types.js";
+export declare const backendFactories: Record<OpenTaskListOptions["type"], BackendFactory>;
+export declare function openTaskList(options: OpenTaskListOptions): Promise<TaskList>;

package/node_modules/@poe-code/task-list/dist/open.js

@@ -0,0 +1,34 @@
+import * as fsPromises from "node:fs/promises";
+import { markdownDirBackend } from "./backends/markdown-dir.js";
+import { yamlFileBackend } from "./backends/yaml-file.js";
+import { validateMachine } from "./state-machine.js";
+import { resolveStateMachine } from "./state.js";
+const DEFAULT_LOCK_STALE_MS = 30_000;
+const DEFAULT_LOCK_RETRIES = 20;
+export const backendFactories = {
+    "markdown-dir": markdownDirBackend,
+    "yaml-file": yamlFileBackend
+};
+function createDefaultFs() {
+    return fsPromises;
+}
+export async function openTaskList(options) {
+    const factory = backendFactories[options.type];
+    if (factory === undefined) {
+        throw new Error(`Unknown task list backend type "${options.type}".`);
+    }
+    const stateMachine = resolveStateMachine(options.stateMachine);
+    validateMachine(stateMachine);
+    const deps = {
+        path: options.path,
+        defaults: {
+            metadata: { ...(options.defaults?.metadata ?? {}) }
+        },
+        lockStaleMs: options.lockStaleMs ?? DEFAULT_LOCK_STALE_MS,
+        lockRetries: options.lockRetries ?? DEFAULT_LOCK_RETRIES,
+        create: options.create ?? false,
+        fs: options.fs ?? createDefaultFs(),
+        stateMachine
+    };
+    return factory(deps);
+}

package/node_modules/@poe-code/task-list/dist/schema/store.schema.json

@@ -0,0 +1,32 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://poe-platform.github.io/poe-code/schemas/task-list/store.schema.json",
+    "title": "Task Store",
+    "description": "YAML multi-list task store.",
+    "type": "object",
+    "properties": {
+        "$schema": {
+            "type": "string",
+            "const": "https://poe-platform.github.io/poe-code/schemas/task-list/store.schema.json"
+        },
+        "kind": {
+            "type": "string",
+            "const": "task-store"
+        },
+        "version": {
+            "type": "integer",
+            "const": 1
+        },
+        "lists": {
+            "type": "object",
+            "additionalProperties": {
+                "type": "object",
+                "additionalProperties": {
+                    "$ref": "./task.schema.json"
+                }
+            }
+        }
+    },
+    "required": ["$schema", "kind", "version", "lists"],
+    "additionalProperties": false
+}

package/node_modules/@poe-code/task-list/dist/schema/task.schema.json

@@ -0,0 +1,33 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://poe-platform.github.io/poe-code/schemas/task-list/task.schema.json",
+    "title": "Task",
+    "description": "Persisted task payload used by task-list backends.",
+    "type": "object",
+    "properties": {
+        "$schema": {
+            "type": "string",
+            "const": "https://poe-platform.github.io/poe-code/schemas/task-list/task.schema.json"
+        },
+        "kind": {
+            "type": "string",
+            "const": "task"
+        },
+        "version": {
+            "type": "integer",
+            "const": 1
+        },
+        "name": {
+            "type": "string",
+            "minLength": 1
+        },
+        "state": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        }
+    },
+    "required": ["name", "state"],
+    "additionalProperties": true
+}

package/node_modules/@poe-code/task-list/dist/state-machine.d.ts

@@ -0,0 +1,16 @@
+import type { Task } from "./types.js";
+export interface StateMachineDef<TState extends string = string, TEvent extends string = string> {
+    readonly initial: TState;
+    readonly states: readonly TState[];
+    readonly events: Readonly<Record<TEvent, EventDef<TState>>>;
+}
+export interface EventDef<TState extends string = string> {
+    readonly from: readonly TState[] | "*";
+    readonly to: TState;
+    readonly guard?: (task: Task) => true | string;
+    readonly onEnter?: (task: Task) => void | Promise<void>;
+    readonly onExit?: (task: Task) => void | Promise<void>;
+}
+export declare function validateMachine(machine: StateMachineDef): void;
+export declare function eventsFromState<TState extends string, TEvent extends string>(machine: StateMachineDef<TState, TEvent>, fromState: TState): readonly TEvent[];
+export declare function findEvent<TState extends string, TEvent extends string>(machine: StateMachineDef<TState, TEvent>, fromState: TState, eventName: TEvent): EventDef<TState> | undefined;

package/node_modules/@poe-code/task-list/dist/state-machine.js

@@ -0,0 +1,67 @@
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStateList(value) {
+    return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function canFireFromState(event, fromState) {
+    if (event.from === "*") {
+        return event.to !== fromState;
+    }
+    return event.from.includes(fromState);
+}
+export function validateMachine(machine) {
+    if (!isRecord(machine)) {
+        throw new TypeError("State machine must be an object.");
+    }
+    if (!isStateList(machine.states)) {
+        throw new TypeError("State machine states must be a string array.");
+    }
+    const states = new Set(machine.states);
+    if (typeof machine.initial !== "string") {
+        throw new TypeError("State machine initial must be a string.");
+    }
+    if (!states.has(machine.initial)) {
+        throw new Error(`Initial state "${machine.initial}" is not declared.`);
+    }
+    if (!isRecord(machine.events)) {
+        throw new TypeError("State machine events must be an object.");
+    }
+    for (const [eventName, event] of Object.entries(machine.events)) {
+        if (!isRecord(event)) {
+            throw new TypeError(`Event "${eventName}" must be an object.`);
+        }
+        if (event.from !== "*" && !isStateList(event.from)) {
+            throw new TypeError(`Event "${eventName}" has an invalid "from" definition.`);
+        }
+        if (typeof event.to !== "string") {
+            throw new TypeError(`Event "${eventName}" target state must be a string.`);
+        }
+        if (!states.has(event.to)) {
+            throw new Error(`Event "${eventName}" references unknown target state "${event.to}".`);
+        }
+        if (event.from !== "*") {
+            for (const fromState of event.from) {
+                if (!states.has(fromState)) {
+                    throw new Error(`Event "${eventName}" references unknown source state "${fromState}".`);
+                }
+            }
+        }
+    }
+}
+export function eventsFromState(machine, fromState) {
+    const events = [];
+    for (const [eventName, event] of Object.entries(machine.events)) {
+        if (canFireFromState(event, fromState)) {
+            events.push(eventName);
+        }
+    }
+    return events;
+}
+export function findEvent(machine, fromState, eventName) {
+    const event = machine.events[eventName];
+    if (event === undefined) {
+        return undefined;
+    }
+    return canFireFromState(event, fromState) ? event : undefined;
+}

package/node_modules/@poe-code/task-list/dist/state.d.ts

@@ -0,0 +1,29 @@
+import { type EventDef, type StateMachineDef } from "./state-machine.js";
+import { type TaskState } from "./types.js";
+export type TaskEvent = "plan" | "start" | "complete" | "archive";
+export declare const defaultStateMachine: {
+    readonly initial: "draft";
+    readonly states: readonly ["draft", "planned", "in-progress", "done", "archived"];
+    readonly events: {
+        readonly plan: {
+            readonly from: readonly ["draft"];
+            readonly to: "planned";
+        };
+        readonly start: {
+            readonly from: readonly ["planned"];
+            readonly to: "in-progress";
+        };
+        readonly complete: {
+            readonly from: readonly ["in-progress"];
+            readonly to: "done";
+        };
+        readonly archive: {
+            readonly from: "*";
+            readonly to: "archived";
+        };
+    };
+};
+export declare function resolveStateMachine(stateMachine?: StateMachineDef): StateMachineDef;
+export declare function assertEvent<TState extends string, TEvent extends string>(machine: StateMachineDef<TState, TEvent>, fromState: TState, eventName: TEvent): EventDef<TState>;
+export declare function assertTransition(from: TaskState, to: TaskState): void;
+export declare function assertTransition<TState extends string, TEvent extends string>(machine: StateMachineDef<TState, TEvent>, from: TState, to: TState): void;