@zq-silk/yui 0.0.0

package/dist/repository/taskWorkspacePreparer.js

@@ -0,0 +1,256 @@
+import { rmdir } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { updateRole } from "../role/role.js";
+import { createRoleWorkspace } from "../worktree/roleWorkspace.js";
+import { NodeGitWorkspace } from "./gitWorkspace.js";
+/**
+ * Prepares one deterministic worktree per Task Role. Git and the deterministic
+ * path remain the physical truth; the compact RoleWorkspace records only the
+ * identity needed to validate launches and safely reconcile archive cleanup.
+ */
+export class FileTaskWorkspacePreparer {
+    store;
+    git;
+    now;
+    worktreeRoot;
+    constructor(home, store, git = new NodeGitWorkspace(), now = () => new Date()) {
+        this.store = store;
+        this.git = git;
+        this.now = now;
+        this.worktreeRoot = join(resolve(home), "worktrees");
+    }
+    async prepareTaskWorkspace(taskId) {
+        const task = requireTask(this.store, taskId);
+        if (task.repositoryId === undefined) {
+            return {
+                taskId,
+                status: task.status === "draft" ? "draft" : "ready",
+                ...(task.cwd === undefined ? {} : { path: task.cwd })
+            };
+        }
+        const repository = this.store.getRepository(task.repositoryId);
+        if (repository === null)
+            throw new Error(`Repository not found: ${task.repositoryId}.`);
+        if (task.status === "draft")
+            return { taskId, status: "draft" };
+        if (task.status === "archived")
+            return this.#cleanupArchived(task, repository.path);
+        const taskRoot = this.#taskRoot(task.id);
+        if (task.cwd !== undefined && resolve(task.cwd) !== taskRoot) {
+            throw new Error(`Task workspace root does not match its deterministic path: ${task.id}.`);
+        }
+        const baseRef = task.baseRef ?? repository.defaultBranch;
+        // A Task base branch may be deleted after its first Role worktree is
+        // created. The persisted starting commit remains a stable base for Roles
+        // added later without introducing a separate ref ledger.
+        const physicalBase = this.store.listRoleWorkspaces(task.id)[0]?.baseCommit ?? baseRef;
+        const prepared = [];
+        for (const role of this.store.listRoles(task.id)) {
+            const workspace = await this.git.ensureWorktree({
+                repositoryPath: repository.path,
+                container: this.worktreeRoot,
+                taskId: task.id,
+                roleName: role.name,
+                baseRef: physicalBase
+            });
+            prepared.push({ roleName: role.name, ...workspace });
+        }
+        const ready = this.store.transaction((store) => {
+            const latest = requireTask(store, task.id);
+            if (latest.status !== "active")
+                return false;
+            if (latest.repositoryId !== repository.id) {
+                throw new Error(`Task repository changed while preparing its workspaces: ${task.id}.`);
+            }
+            const now = this.now();
+            for (const physical of prepared) {
+                const role = store.getRole(task.id, physical.roleName);
+                if (role === null)
+                    continue;
+                const existing = store.getRoleWorkspace(task.id, role.name);
+                const workspace = existing ?? createRoleWorkspace({
+                    taskId: task.id,
+                    roleName: role.name,
+                    repositoryId: repository.id,
+                    path: physical.path,
+                    branch: physical.branch,
+                    baseRef,
+                    baseCommit: physical.baseCommit
+                }, now);
+                assertWorkspaceIdentity(workspace, {
+                    taskId: task.id,
+                    roleName: role.name,
+                    repositoryId: repository.id,
+                    path: physical.path,
+                    branch: physical.branch,
+                    baseRef
+                });
+                if (role.workspace !== workspace.path) {
+                    store.saveRole(task.id, updateRole(role, { workspace: workspace.path }, now));
+                }
+                if (existing === null)
+                    store.saveRoleWorkspace(task.id, workspace);
+            }
+            const roles = store.listRoles(task.id);
+            const allReady = roles.length > 0 && roles.every((role) => {
+                const workspace = store.getRoleWorkspace(task.id, role.name);
+                return workspace !== null
+                    && workspace.repositoryId === repository.id
+                    && workspace.path === role.workspace;
+            });
+            if (allReady && latest.cwd !== taskRoot) {
+                store.saveTask({ ...latest, cwd: taskRoot, updatedAt: now.toISOString() });
+            }
+            else if (!allReady && latest.cwd !== undefined) {
+                const { cwd: _cwd, ...withoutWorkspace } = latest;
+                store.saveTask({ ...withoutWorkspace, updatedAt: now.toISOString() });
+            }
+            return allReady;
+        });
+        if (ready)
+            return { taskId, status: "ready", path: taskRoot };
+        // Archive may win while Git is creating worktrees. Re-read state and use
+        // the same dirty-preserving archive policy before any scheduler delivery.
+        const latest = requireTask(this.store, task.id);
+        if (latest.status === "archived")
+            return this.#cleanupArchived(latest, repository.path);
+        return { taskId, status: latest.status === "draft" ? "draft" : "pending" };
+    }
+    async reconcileTaskWorkspaces() {
+        return [
+            ...await this.prepareActiveTaskWorkspaces(),
+            ...await this.cleanupArchivedTaskWorkspaces()
+        ];
+    }
+    async prepareActiveTaskWorkspaces() {
+        const results = [];
+        for (const task of this.store.listTasks()) {
+            if (task.repositoryId === undefined || task.status !== "active")
+                continue;
+            try {
+                results.push(await this.prepareTaskWorkspace(task.id));
+            }
+            catch (error) {
+                results.push(failedPreparation(task.id, error));
+            }
+        }
+        return results;
+    }
+    async cleanupArchivedTaskWorkspaces() {
+        const results = [];
+        for (const task of this.store.listTasks()) {
+            if (task.repositoryId === undefined || task.status !== "archived")
+                continue;
+            try {
+                results.push(await this.prepareTaskWorkspace(task.id));
+            }
+            catch (error) {
+                results.push(failedPreparation(task.id, error));
+            }
+        }
+        return results;
+    }
+    async #cleanupArchived(task, repositoryPath) {
+        const removals = new Map();
+        const failures = [];
+        for (const role of this.store.listRoles(task.id)) {
+            try {
+                const removal = await this.git.removeWorktree({
+                    repositoryPath,
+                    container: this.worktreeRoot,
+                    taskId: task.id,
+                    roleName: role.name
+                });
+                removals.set(role.name, removal);
+                if (removal !== "dirty") {
+                    this.#recordArchivedRoleCleanup(task.id, repositoryPath, role.name);
+                }
+            }
+            catch (error) {
+                failures.push(`${role.name}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        const dirty = [...removals.values()].some((removal) => removal === "dirty");
+        if (failures.length > 0) {
+            return {
+                taskId: task.id,
+                status: "failed",
+                path: this.#taskRoot(task.id),
+                error: `Role worktree cleanup failed (${failures.join("; ")})`
+            };
+        }
+        this.#recordArchivedTaskCleanup(task.id, dirty);
+        if (!dirty)
+            await removeEmptyDirectory(this.#taskRoot(task.id));
+        return dirty
+            ? { taskId: task.id, status: "archived-dirty", path: this.#taskRoot(task.id) }
+            : { taskId: task.id, status: "archived-clean" };
+    }
+    #recordArchivedRoleCleanup(taskId, repositoryPath, roleName) {
+        this.store.transaction((store) => {
+            const latest = requireTask(store, taskId);
+            if (latest.status !== "archived")
+                return;
+            const now = this.now();
+            const role = store.getRole(taskId, roleName);
+            if (role === null)
+                return;
+            if (role.workspace === repositoryPath
+                && store.getRoleWorkspace(taskId, role.name) === null)
+                return;
+            if (role.workspace !== repositoryPath) {
+                store.saveRole(taskId, updateRole(role, { workspace: repositoryPath }, now));
+            }
+            store.removeRoleWorkspace(taskId, role.name);
+        });
+    }
+    #recordArchivedTaskCleanup(taskId, dirty) {
+        this.store.transaction((store) => {
+            const latest = requireTask(store, taskId);
+            if (latest.status !== "archived")
+                return;
+            if (!dirty && latest.cwd !== undefined) {
+                const { cwd: _cwd, ...withoutWorkspace } = latest;
+                store.saveTask({ ...withoutWorkspace, updatedAt: this.now().toISOString() });
+            }
+        });
+    }
+    #taskRoot(taskId) {
+        return join(this.worktreeRoot, taskId);
+    }
+}
+function failedPreparation(taskId, error) {
+    return {
+        taskId,
+        status: "failed",
+        error: error instanceof Error ? error.message : String(error)
+    };
+}
+function assertWorkspaceIdentity(workspace, expected) {
+    for (const key of [
+        "taskId", "roleName", "repositoryId", "path", "branch", "baseRef"
+    ]) {
+        if (workspace[key] !== expected[key]) {
+            throw new Error(`RoleWorkspace ${key} does not match its deterministic identity: ${expected.taskId}/${expected.roleName}.`);
+        }
+    }
+}
+async function removeEmptyDirectory(path) {
+    try {
+        await rmdir(path);
+    }
+    catch (error) {
+        if (!isErrno(error, "ENOENT") && !isErrno(error, "ENOTEMPTY"))
+            throw error;
+    }
+}
+function isErrno(value, code) {
+    return typeof value === "object" && value !== null && "code" in value
+        && value.code === code;
+}
+function requireTask(store, taskId) {
+    const task = store.getTask(taskId);
+    if (task === null)
+        throw new Error(`Task not found: ${taskId}.`);
+    return task;
+}

package/dist/role/role.js

@@ -0,0 +1,246 @@
+export function createRoleAgentBinding(agent, config) {
+    const agentId = requireSafeIdentity(agent.id, "Role Agent id");
+    const adapterId = requireSupportedAdapterId(agent.adapterId);
+    const effectiveConfig = config ?? { adapterId };
+    if (effectiveConfig.adapterId !== adapterId) {
+        throw new Error(`Role Agent config adapter does not match Agent: ${agentId}.`);
+    }
+    return cloneBinding({ agentId, adapterId, config: effectiveConfig });
+}
+export function createRole(taskId, name, bindings, activeAgentId, workspace, now, profile = {}) {
+    const owner = createRoleOwner(name, bindings, activeAgentId, workspace, now, profile);
+    return validateTaskRole({
+        ...owner,
+        taskId: requireSafeIdentity(taskId, "Task id"),
+        status: "idle"
+    });
+}
+export function createGlobalRole(name, bindings, activeAgentId, workspace, now, profile = {}) {
+    return createRoleOwner(name, bindings, activeAgentId, workspace, now, profile);
+}
+export function copyGlobalRoleToTaskRole(globalRole, taskId, now, name = globalRole.name) {
+    validateGlobalRole(globalRole);
+    const timestamp = now.toISOString();
+    return validateTaskRole({
+        ...cloneProfile(globalRole),
+        schemaVersion: 2,
+        taskId: requireSafeIdentity(taskId, "Task id"),
+        name: requireSafeIdentity(name, "Role name"),
+        activeAgentId: globalRole.activeAgentId,
+        agentBindings: cloneBindings(globalRole.agentBindings),
+        workspace: globalRole.workspace,
+        status: "idle",
+        createdAt: timestamp,
+        updatedAt: timestamp
+    });
+}
+export function activeRoleAgentBinding(role) {
+    validateRoleOwner(role);
+    return role.agentBindings[role.activeAgentId];
+}
+export function updateGlobalRole(role, patch, now) {
+    validateGlobalRole(role);
+    const updated = {
+        ...role,
+        ...cloneRolePatch(patch),
+        updatedAt: now.toISOString()
+    };
+    clearProfileFields(updated, patch);
+    return validateGlobalRole(updated);
+}
+export function updateRole(role, patch, now) {
+    validateTaskRole(role);
+    const updated = {
+        ...role,
+        ...cloneRolePatch(patch),
+        updatedAt: now.toISOString()
+    };
+    clearProfileFields(updated, patch);
+    return validateTaskRole(updated);
+}
+export function updateRoleStatus(role, status, now) {
+    validateTaskRole(role);
+    if (!isRoleStatus(status))
+        throw new Error(`Role status is invalid: ${status}.`);
+    return { ...role, status, updatedAt: now.toISOString() };
+}
+export function switchActiveRoleAgent(role, sessions, targetAgentId, runtime, now) {
+    validateRoleOwner(role);
+    if (runtime.activeRun) {
+        throw new Error("Cannot switch Role Agent while an active AgentRun exists.");
+    }
+    if (runtime.nativeProcessRunning) {
+        throw new Error("Cannot switch Role Agent while the native Agent process is running.");
+    }
+    const normalizedTarget = requireSafeIdentity(targetAgentId, "Target Agent id");
+    if (!Object.hasOwn(role.agentBindings, normalizedTarget)) {
+        throw new Error(`Role Agent is not bound: ${normalizedTarget}.`);
+    }
+    assertSessionOwnerMatchesRole(role, sessions);
+    if (sessions.activeAgentId !== role.activeAgentId) {
+        throw new Error(`Role session active Agent does not match Role: ${role.name}.`);
+    }
+    const fromAgentId = role.activeAgentId;
+    const mode = sessions.sessions[normalizedTarget] === undefined ? "new" : "resume";
+    const timestamp = now.toISOString();
+    const updatedRole = "taskId" in role
+        ? updateRole(role, { activeAgentId: normalizedTarget }, now)
+        : updateGlobalRole(role, { activeAgentId: normalizedTarget }, now);
+    const updatedSessions = {
+        ...sessions,
+        activeAgentId: normalizedTarget,
+        updatedAt: timestamp
+    };
+    return {
+        role: updatedRole,
+        sessions: updatedSessions,
+        mode,
+        event: {
+            type: "role.agent_switched",
+            payload: { fromAgentId, toAgentId: normalizedTarget, mode }
+        }
+    };
+}
+export function validateGlobalRole(role) {
+    return validateRoleOwner(role);
+}
+export function validateTaskRole(role) {
+    requireSafeIdentity(role.taskId, "Task id");
+    if (!isRoleStatus(role.status))
+        throw new Error(`Role status is invalid: ${role.status}.`);
+    return validateRoleOwner(role);
+}
+function createRoleOwner(name, bindings, activeAgentId, workspace, now, profile) {
+    const mappedBindings = {};
+    for (const sourceBinding of bindings) {
+        const binding = validateRoleAgentBinding(cloneBinding(sourceBinding));
+        if (Object.hasOwn(mappedBindings, binding.agentId)) {
+            throw new Error(`Role Agent binding is duplicated: ${binding.agentId}.`);
+        }
+        mappedBindings[binding.agentId] = binding;
+    }
+    const timestamp = now.toISOString();
+    return validateGlobalRole({
+        ...cloneProfile(profile),
+        schemaVersion: 2,
+        name: requireSafeIdentity(name, "Role name"),
+        activeAgentId: requireSafeIdentity(activeAgentId, "Role active Agent id"),
+        agentBindings: mappedBindings,
+        workspace: requireText(workspace, "Role workspace"),
+        createdAt: timestamp,
+        updatedAt: timestamp
+    });
+}
+function validateRoleOwner(role) {
+    if (role.schemaVersion !== 2)
+        throw new Error("Role schema version is invalid.");
+    requireSafeIdentity(role.name, "Role name");
+    requireSafeIdentity(role.activeAgentId, "Role active Agent id");
+    requireText(role.workspace, "Role workspace");
+    const entries = Object.entries(role.agentBindings);
+    if (entries.length === 0)
+        throw new Error("Role requires at least one Agent binding.");
+    for (const [agentId, binding] of entries) {
+        validateRoleAgentBinding(binding);
+        if (agentId !== binding.agentId) {
+            throw new Error(`Role Agent binding identity is inconsistent: ${agentId}.`);
+        }
+    }
+    if (!Object.hasOwn(role.agentBindings, role.activeAgentId)) {
+        throw new Error(`Role active Agent is not bound: ${role.activeAgentId}.`);
+    }
+    return role;
+}
+function validateRoleAgentBinding(binding) {
+    const agentId = requireSafeIdentity(binding.agentId, "Role Agent id");
+    const adapterId = requireSupportedAdapterId(binding.adapterId);
+    if (binding.config === null || typeof binding.config !== "object" || Array.isArray(binding.config)) {
+        throw new Error(`Role Agent config is invalid: ${agentId}.`);
+    }
+    if (binding.config.adapterId !== adapterId) {
+        throw new Error(`Role Agent binding adapter is inconsistent: ${agentId}.`);
+    }
+    return binding;
+}
+function assertSessionOwnerMatchesRole(role, sessions) {
+    const matches = "taskId" in role
+        ? sessions.owner.scope === "task"
+            && sessions.owner.taskId === role.taskId
+            && sessions.owner.roleName === role.name
+        : sessions.owner.scope === "global" && sessions.owner.roleName === role.name;
+    if (!matches)
+        throw new Error(`Role session owner does not match Role: ${role.name}.`);
+}
+function cloneRolePatch(patch) {
+    return {
+        ...(patch.name === undefined ? {} : { name: requireSafeIdentity(patch.name, "Role name") }),
+        ...(patch.activeAgentId === undefined
+            ? {}
+            : { activeAgentId: requireSafeIdentity(patch.activeAgentId, "Role active Agent id") }),
+        ...(patch.workspace === undefined ? {} : { workspace: requireText(patch.workspace, "Role workspace") }),
+        ...(patch.agentBindings === undefined ? {} : { agentBindings: cloneBindings(patch.agentBindings) }),
+        ...cloneProfile(patch)
+    };
+}
+function cloneBindings(bindings) {
+    return Object.fromEntries(Object.entries(bindings).map(([agentId, binding]) => [agentId, cloneBinding(binding)]));
+}
+function cloneBinding(binding) {
+    return {
+        agentId: binding.agentId,
+        adapterId: binding.adapterId,
+        config: cloneJson(binding.config)
+    };
+}
+function cloneProfile(profile) {
+    return {
+        ...(profile.description === undefined ? {} : { description: profile.description }),
+        ...(profile.responsibilities === undefined ? {} : { responsibilities: [...profile.responsibilities] }),
+        ...(profile.constraints === undefined ? {} : { constraints: [...profile.constraints] }),
+        ...(profile.expectedOutput === undefined ? {} : { expectedOutput: profile.expectedOutput }),
+        ...(profile.systemPrompt === undefined ? {} : { systemPrompt: profile.systemPrompt }),
+        ...(profile.skills === undefined ? {} : { skills: [...profile.skills] })
+    };
+}
+function clearProfileFields(role, patch) {
+    for (const key of [
+        "description",
+        "responsibilities",
+        "constraints",
+        "expectedOutput",
+        "systemPrompt",
+        "skills"
+    ]) {
+        if (Object.hasOwn(patch, key) && patch[key] === undefined)
+            delete role[key];
+    }
+}
+function cloneJson(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function requireSupportedAdapterId(value) {
+    const normalized = requireText(value, "Role Agent adapter id");
+    if (normalized !== "codex" && normalized !== "claude") {
+        throw new Error(`Role Agent adapter is unsupported: ${normalized}.`);
+    }
+    return normalized;
+}
+function requireSafeIdentity(value, label) {
+    const normalized = requireText(value, label);
+    if (["__proto__", "prototype", "constructor", ".", ".."].includes(normalized)
+        || /[\/\\\0]/.test(normalized)) {
+        throw new Error(`${label} is invalid.`);
+    }
+    return normalized;
+}
+function requireText(value, label) {
+    if (typeof value !== "string" || value.includes("\0"))
+        throw new Error(`${label} is invalid.`);
+    const normalized = value.trim();
+    if (normalized.length === 0)
+        throw new Error(`${label} is required.`);
+    return normalized;
+}
+function isRoleStatus(value) {
+    return ["idle", "running", "detached", "exited", "failed"].includes(value);
+}

package/dist/role/systemRoles.js

@@ -0,0 +1,20 @@
+export const SYSTEM_OPERATOR_ROLE = "operator";
+export const SYSTEM_LEADER_ROLE = "leader";
+export const SYSTEM_WORKER_ROLE = "worker";
+export const SYSTEM_ROLE_NAMES = [
+    SYSTEM_OPERATOR_ROLE,
+    SYSTEM_LEADER_ROLE,
+    SYSTEM_WORKER_ROLE
+];
+export function isSystemRoleName(name) {
+    return SYSTEM_ROLE_NAMES.includes(name);
+}
+export function systemRoleDescription(name) {
+    if (name === SYSTEM_OPERATOR_ROLE)
+        return "global user-facing CLI operator";
+    if (name === SYSTEM_LEADER_ROLE)
+        return "task leader and role coordinator";
+    if (name === SYSTEM_WORKER_ROLE)
+        return "task worker executing delegated work";
+    return "";
+}

package/dist/run/agentRun.js

@@ -0,0 +1,102 @@
+export function createAgentRun(id, taskId, roleName, mode, input, now, context = {}) {
+    if (mode !== "new" && mode !== "resume") {
+        throw new Error(`Agent run dispatch mode is invalid: ${mode}.`);
+    }
+    const timestamp = now.toISOString();
+    return {
+        schemaVersion: 1,
+        id: requireSafeIdentity(id, "Agent run id"),
+        taskId: requireSafeIdentity(taskId, "Task id"),
+        roleName: requireSafeIdentity(roleName, "Role name"),
+        mode,
+        input: requireText(input, "Agent run input"),
+        ...(context.workItemId === undefined
+            ? {}
+            : { workItemId: requireSafeIdentity(context.workItemId, "Work item id") }),
+        status: "active",
+        createdAt: timestamp,
+        updatedAt: timestamp
+    };
+}
+export function isActiveAgentRun(run) {
+    return run.status === "active";
+}
+export function markAgentRunDelivered(run, now) {
+    if (run.status !== "active") {
+        throw new Error(`Cannot deliver a terminal Agent run: ${run.id}.`);
+    }
+    if (run.deliveredAt !== undefined)
+        return run;
+    const timestamp = now.toISOString();
+    return { ...run, deliveredAt: timestamp, updatedAt: timestamp };
+}
+export function validateAgentRun(run) {
+    if (run.schemaVersion !== 1)
+        throw new Error("Agent run must use schemaVersion 1.");
+    requireSafeIdentity(run.id, "Agent run id");
+    requireSafeIdentity(run.taskId, "Task id");
+    requireSafeIdentity(run.roleName, "Role name");
+    if (run.mode !== "new" && run.mode !== "resume") {
+        throw new Error(`Agent run dispatch mode is invalid: ${String(run.mode)}.`);
+    }
+    requireText(run.input, "Agent run input");
+    if (run.workItemId !== undefined)
+        requireSafeIdentity(run.workItemId, "Work item id");
+    if (!["active", "yielded", "failed"].includes(run.status)) {
+        throw new Error(`Agent run status is invalid: ${String(run.status)}.`);
+    }
+    requireTimestamp(run.createdAt, "Agent run createdAt");
+    requireTimestamp(run.updatedAt, "Agent run updatedAt");
+    if (run.deliveredAt !== undefined)
+        requireTimestamp(run.deliveredAt, "Agent run deliveredAt");
+    if (run.status === "active") {
+        if (run.summary !== undefined || run.endedAt !== undefined) {
+            throw new Error("An active Agent run cannot have terminal metadata.");
+        }
+    }
+    else {
+        requireText(run.summary ?? "", "Agent run summary");
+        requireTimestamp(run.endedAt ?? "", "Agent run endedAt");
+    }
+    return run;
+}
+export function yieldAgentRun(run, summary, now) {
+    return finishAgentRun(run, "yielded", requireText(summary, "Agent run summary"), now);
+}
+export function failAgentRun(run, summary, now) {
+    return finishAgentRun(run, "failed", requireText(summary, "Agent run summary"), now);
+}
+function finishAgentRun(run, status, summary, now) {
+    if (run.status !== "active") {
+        throw new Error(`Agent run is already terminal: ${run.id}.`);
+    }
+    const timestamp = now.toISOString();
+    return {
+        ...run,
+        status,
+        summary,
+        updatedAt: timestamp,
+        endedAt: timestamp
+    };
+}
+function requireSafeIdentity(value, label) {
+    const normalized = requireText(value, label);
+    if (["__proto__", "prototype", "constructor", ".", ".."].includes(normalized)
+        || /[\/\\\0]/.test(normalized)) {
+        throw new Error(`${label} is invalid.`);
+    }
+    return normalized;
+}
+function requireText(value, label) {
+    if (typeof value !== "string" || value.includes("\0"))
+        throw new Error(`${label} is invalid.`);
+    const normalized = value.trim();
+    if (normalized.length === 0)
+        throw new Error(`${label} is required.`);
+    return normalized;
+}
+function requireTimestamp(value, label) {
+    if (typeof value !== "string" || !Number.isFinite(Date.parse(value))) {
+        throw new Error(`${label} must be an ISO timestamp.`);
+    }
+}