cozyclay 3.0.3 → 3.1.0

package/bin/agent/studio-tasks.mjs

@@ -0,0 +1,156 @@
+// Parallel Studio tasks, P2 (the server; plan: ~/.claude/plans/parallel-studio-agents.md, cases by number). The main
+// agent answers the user at once and hands work to tasks; each task is an ordinary Studio agent run (studio-prompt.mjs,
+// its own history) inside task.begin..finish on its scope (src/bus-tasks.js). This file is the board: it queues, starts
+// and ends tasks and tells the main agent what happened, never what it hopes happened.
+//   - at most CAP running tasks; the rest wait in order (11)
+//   - a task whose scope another running task holds waits for it; the bus is the authority (SCOPE_BUSY at begin) (1)
+//   - dependsOn: a task starts after those are done and hears their summaries; a failed one fails it (8)
+//   - a second task starts only once the first one's model has answered, or STAGGER ms passed: the shared prompt prefix
+//     is then cached once, not written by every task at the same moment (12)
+//   - usage and cost per task (13); summaries are capped so the main agent's context stays small (16)
+//   - a run whose Studio went away pauses, and resumes when the main agent next sees the same scene; another scene fails
+//     it (14)
+//   - the same instructions on the same scope as a queued or running task are not started twice (19)
+//   - a task that runs past MAX_MS or MAX_TOOLS tool calls is stopped and reported as such (20)
+import { randomUUID } from "node:crypto";
+import { isScopeKey, scopeConflict } from "../../src/bus-task-scopes.js";
+
+export const TASK_LIMITS = Object.freeze({ cap: 3, staggerMs: 1500, maxMs: 20 * 60_000, maxTools: 120, summaryChars: 1200, receipts: 8 });
+const ACTIVE = new Set(["queued", "waiting", "starting", "running", "paused"]);
+const ENDED = new Set(["done", "failed", "cancelled"]);
+const norm = text => String(text ?? "").toLowerCase().replace(/\s+/g, " ").trim();
+const clip = (text, n) => (text.length > n ? `${text.slice(0, n - 1)}…` : text);
+
+/**
+ * run(task, { resume }) runs one task to its end and answers { status: "done" | "failed" | "cancelled" | "lost" |
+ * "scopeBusy", reply, receipts, usage, error }; it calls task.onFrame(frame) for every frame. emit(event) tells the
+ * main agent (task.queued, task.started, task.done, task.failed, task.cancelled, task.paused, task.resumed).
+ */
+export function createTaskBoard({ run, emit = () => {}, now = Date.now, setTimer = setTimeout, clearTimer = clearTimeout, limits = {} } = {}) {
+	const L = { ...TASK_LIMITS, ...limits }, tasks = new Map();
+	let lastStart = null, scheduled = null;
+	const list = () => [...tasks.values()];
+	const running = () => list().filter(task => ["starting", "running"].includes(task.status));
+	const scopes = () => new Map(running().map(task => [task.taskId, { taskId: task.taskId, title: task.title, keys: new Set(task.scope) }]));
+	const view = task => ({ taskId: task.taskId, title: task.title, status: task.status, scope: task.scope, ...(task.reason ? { reason: task.reason } : {}), ...(task.turnId ? { turnId: task.turnId } : {}),
+		...(task.dependsOn.length ? { dependsOn: task.dependsOn } : {}), tools: task.tools, usage: task.usage, ...(task.summary ? { summary: task.summary } : {}) });
+	const tell = (type, task, extra = {}) => emit({ type, at: now(), ...view(task), ...extra });
+
+	function dispatch({ title, instructions, scope, reads = [], dependsOn = [] }) {
+		if (typeof instructions !== "string" || !instructions.trim()) throw Object.assign(new Error("A task needs instructions."), { code: "INVALID_ARGUMENT" });
+		if (!Array.isArray(scope) || !scope.length || scope.some(key => !isScopeKey(key))) throw Object.assign(new Error("scope: one or more keys object:<id>, character:<id>, shot:<id>, stage, timeline or scene."), { code: "INVALID_ARGUMENT" });
+		const unknown = dependsOn.find(id => !tasks.has(id));
+		if (unknown) throw Object.assign(new Error(`dependsOn: no task ${unknown}.`), { code: "INVALID_ARGUMENT" });
+		const same = list().find(task => ACTIVE.has(task.status) && norm(task.instructions) === norm(instructions) && [...task.scope].sort().join() === [...scope].sort().join());
+		if (same) return { duplicateOf: same.taskId, ...view(same) };
+		const task = { taskId: randomUUID(), title: clip(String(title || instructions).trim(), 120), instructions, scope: [...new Set(scope)], reads, dependsOn,
+			status: "queued", tools: 0, usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, requests: 0 }, createdAt: now(), warm: false };
+		tasks.set(task.taskId, task);
+		tell("task.queued", task);
+		schedule();
+		return view(task);
+	}
+
+	// What still holds a queued task back, or null when it may start now.
+	function blocker(task) {
+		const failed = task.dependsOn.map(id => tasks.get(id)).find(dep => ["failed", "cancelled"].includes(dep.status));
+		if (failed) return { fail: `it depends on task ${failed.taskId} (${failed.title}), which ${failed.status === "failed" ? "failed" : "was cancelled"}` };
+		const open = task.dependsOn.map(id => tasks.get(id)).find(dep => dep.status !== "done");
+		if (open) return { wait: `waits for task ${open.taskId} (${open.title}) to finish` };
+		const held = scopeConflict(task.taskId, task.scope, scopes());
+		if (held) return { wait: `${held}` };
+		if (running().length >= L.cap) return { wait: `${L.cap} tasks are running; it starts when one ends` };
+		return null;
+	}
+
+	function schedule() {
+		if (scheduled) return;
+		for (const task of list().filter(task => ["queued", "waiting"].includes(task.status)).sort((a, b) => a.createdAt - b.createdAt)) {
+			const held = blocker(task);
+			if (held?.fail) { end(task, "failed", { reason: held.fail }); continue; }
+			if (held) { if (task.reason !== held.wait) { task.status = "waiting"; task.reason = held.wait; tell("task.waiting", task); } continue; }
+			// Cache warm-up: the previous start's model has not answered yet, and STAGGER has not passed.
+			const wait = lastStart && !lastStart.warm ? lastStart.at + L.staggerMs - now() : 0;
+			if (wait > 0) { scheduled = setTimer(() => { scheduled = null; schedule(); }, wait); return; }
+			start(task);
+		}
+	}
+
+	function rescheduleNow() { if (scheduled) { clearTimer(scheduled); scheduled = null; } schedule(); }
+
+	function start(task, resume = null) {
+		task.status = "starting"; task.reason = undefined; task.startedAt ??= now();
+		lastStart = { at: now(), warm: false, taskId: task.taskId };
+		const mark = lastStart;
+		task.controller = new AbortController();
+		const deps = task.dependsOn.map(id => tasks.get(id)).map(dep => ({ taskId: dep.taskId, title: dep.title, summary: dep.summary }));
+		task.timer = setTimer(() => stop(task, `it ran past ${Math.round(L.maxMs / 60_000)} minutes`), L.maxMs);
+		task.onFrame = frame => {
+			if (task.status === "starting") { task.status = "running"; tell(resume ? "task.resumed" : "task.started", task); }
+			if (!mark.warm && ["text.delta", "tool.start", "thinking.delta"].includes(frame.type)) { mark.warm = true; rescheduleNow(); }
+			if (frame.type === "tool.start" && ++task.tools > L.maxTools) stop(task, `it made more than ${L.maxTools} tool calls`);
+		};
+		Promise.resolve().then(() => run(task, { resume, deps, signal: task.controller.signal })).then(result => settle(task, result), error => settle(task, { status: "failed", error }));
+	}
+
+	function settle(task, result) {
+		clearTimer(task.timer);
+		if (lastStart?.taskId === task.taskId) lastStart.warm = true;
+		for (const key of Object.keys(task.usage)) if (Number.isFinite(result?.usage?.[key])) task.usage[key] += result.usage[key];
+		if (result.status === "scopeBusy") { task.status = "waiting"; task.reason = result.error?.message ?? "its scope is held by another task"; tell("task.waiting", task); }
+		else if (result.status === "lost") { task.status = "paused"; task.reason = "Studio disconnected; it resumes when Studio reconnects to the same scene"; task.sceneId = result.sceneId; tell("task.paused", task); }
+		else {
+			const summary = { reply: clip(String(result.reply ?? "").trim(), L.summaryChars), receipts: (result.receipts ?? []).slice(-L.receipts) };
+			// A cancel that arrived after the run finished cannot take it back: it stays done (and can be undone).
+			end(task, task.stopReason ? "failed" : task.cancelled && result.status !== "done" ? "cancelled" : result.status, { reason: task.stopReason ?? (result.status === "failed" ? clip(String(result.error?.message ?? result.error ?? "the run failed"), 300) : undefined), summary });
+		}
+		rescheduleNow();
+	}
+
+	function end(task, status, { reason, summary } = {}) {
+		task.status = status; task.reason = reason; task.endedAt = now();
+		if (summary) task.summary = summary;
+		tell(`task.${status === "done" ? "done" : status}`, task);
+	}
+
+	function stop(task, reason) {
+		if (!["starting", "running"].includes(task.status)) return;
+		task.stopReason = `stopped: ${reason}; ask the user whether to continue`;
+		task.controller.abort(new Error(task.stopReason));
+	}
+
+	return {
+		dispatch,
+		board: () => list().map(view),
+		get: taskId => tasks.get(taskId),
+		/** Cancels a queued task, or stops a running one (its keys go back: task.cancel). */
+		cancel(taskId) {
+			const task = tasks.get(taskId);
+			if (!task || ENDED.has(task.status)) return null;
+			if (["queued", "waiting", "paused"].includes(task.status)) { end(task, "cancelled", { reason: "cancelled before it ran" }); schedule(); return view(task); }
+			task.cancelled = true; task.controller.abort(new Error("cancelled"));
+			return view(task);
+		},
+		/** A Studio context the main agent saw: paused tasks of that scene resume there, others fail. */
+		reconnect(sceneId) {
+			for (const task of list().filter(task => task.status === "paused")) {
+				if (task.sceneId && task.sceneId !== sceneId) end(task, "failed", { reason: "Studio came back on another scene" });
+				else start(task, { note: "Studio reconnected after a disconnect. Read the scene again before you continue the task from where you were." });
+			}
+			schedule();
+		},
+		running: () => running().map(view),
+		dispose() { if (scheduled) clearTimer(scheduled); for (const task of running()) task.controller.abort(new Error("closed")); },
+	};
+}
+
+/** The header a task's run reads before its instructions (after the cached system prompt and motion reference). */
+export function taskHeader(task, { deps = [], resume = null } = {}) {
+	return [`<task id="${task.taskId}">`,
+		`You are one of several tasks working on this scene at once. Your scope (the only things you may change): ${task.scope.join(", ")}.`,
+		"Everything else is read-only for you: another task or the user may be changing it. A command outside your scope is refused with SCOPE_DENIED; ask for more with run_action task.requestScope { taskId, scope }, and if that answers SCOPE_BUSY, do what you can inside your scope and say what is left.",
+		"When you finish, end with a short report for the coordinator in English: what you changed (receipt ids, ids), the QA problems left, and anything not done. The coordinator talks to the user.",
+		...deps.map(dep => `Earlier task ${dep.taskId} (${dep.title}) is done: ${dep.summary?.reply ?? ""}`),
+		...(resume?.note ? [resume.note] : []),
+		"</task>", "", task.instructions].join("\n");
+}

package/bin/agent/studio-tools.mjs

@@ -25,7 +25,7 @@ export function createStudioTools({ liveHub, workspaceHandle, session, resolveIm
     const command = validateStudioCommand({ name, args });
     const action = name === "run_action" ? declared.get(command.args.action) : undefined;
     const payload = mutationNames.has(name) && session?.admission
-      ? { name, args: command.args, commandId: session.admission.commandId(), host: session.admission.host, expectedRevision: session.admission.revision, ...(session.admission.turnId ? { turnId: session.admission.turnId } : {}) }
+      ? { name, args: command.args, commandId: session.admission.commandId(), host: session.admission.host, expectedRevision: session.admission.revision, ...(session.admission.turnId ? { turnId: session.admission.turnId } : {}), ...(session.admission.taskId ? { taskId: session.admission.taskId } : {}) }
       : command.args;
     Object.assign(scratch, { refusedRevision: payload.expectedRevision });
     let result;
@@ -38,7 +38,8 @@ export function createStudioTools({ liveHub, workspaceHandle, session, resolveIm
     } catch (error) {
       // A STALE_SCENE re-admits whichever family met it, so the retry the
       // model is told to make is admitted at the live revision.
-      if (session?.admission && (error?.code === "STALE_SCENE" || (mutationNames.has(name) && error?.code === "UNCERTAIN_APPLY"))) scratch.fresh = await session.admission.refresh();
+      // A refresh that fails (the editor went away) keeps the error that happened, not the refresh's.
+      if (session?.admission && (error?.code === "STALE_SCENE" || (mutationNames.has(name) && error?.code === "UNCERTAIN_APPLY"))) scratch.fresh = await session.admission.refresh().catch(() => null);
       throw error;
     }
     if (result?.ok === false) {

package/bin/agent/studio-turn-transaction.mjs

@@ -0,0 +1,76 @@
+// The editor transaction a Studio run holds while its model works.
+//
+// A single turn (the default): one user message is one editor transaction. Every Studio turn whose editor reports a
+// previsMode opens agent.turn.begin and closes agent.turn.finish, so all of its mutations land as ONE history entry and
+// one receipt frame. A context without a previsMode runs unwrapped (an editor that predates turn transactions).
+//
+// A task (parallel Studio tasks, P2): the run holds task.begin { taskId, scope, reads, title } instead, so other tasks
+// edit other keys of the same scene meanwhile. Its commands carry the taskId and commit one by one (src/bus-tasks.js).
+// A stopped task cancels (its keys go back to where they were); a task that ends, even on an error, finishes and keeps
+// what it did. A task whose Studio went away (the browser reloaded) is neither: the editor that held it is gone.
+//
+// mark() records where a script starts; rollback() undoes only the edits after it and keeps the run open, so earlier
+// edits still land.
+import { randomUUID } from "node:crypto";
+
+// The Studio went away (a reload, a closed tab): no editor answers, or it went while a command ran (UNCERTAIN_APPLY: the
+// command may or may not have landed; mcp/live-hub.mjs).
+export const LOST_STUDIO = new Set(["LIVE_HUB_UNAVAILABLE", "STALE_HANDLE", "NO_EDITOR", "UNCERTAIN_APPLY"]);
+
+export function studioTransaction({ hub, context, turnId, admission, task = null, signal, plain = false }) {
+	// The main agent holds no transaction (plain): its one quick edit opens a task of its own.
+	const wrapped = !plain && Boolean(task || context.scene?.previsMode);
+	const host = Object.fromEntries(["workspaceId", "documentEpoch", "sceneId", "sceneEpoch"].map(key => [key, context.host[key]]));
+	const verb = name => task ? `task.${name === "begin" ? "begin" : name}` : `agent.turn.${name}`;
+	const control = async (name, extra = {}) => {
+		const args = task ? { taskId: task.taskId, ...extra } : { turnId };
+		const receipt = await hub.command("run_action", {
+			name: "run_action", args: { action: verb(name), args }, ...(task ? { taskId: task.taskId } : { turnId }),
+			commandId: randomUUID(), host, expectedRevision: admission.revision,
+		}, context.host.workspaceHandle);
+		if (!receipt.ok) throw Object.assign(new Error(receipt.message), { code: receipt.code });
+		return receipt;
+	};
+	const owner = task ? "taskId" : "turnId", id = task ? task.taskId : turnId;
+	const open = async () => {
+		await control("begin", task ? { scope: task.scope, ...(task.reads?.length ? { reads: task.reads } : {}), ...(task.title ? { title: task.title.slice(0, 120) } : {}) } : {});
+		admission[owner] = id;
+	};
+	return {
+		mark: async () => (admission[owner] === id ? control("mark") : null),
+		async rollback() {
+			if (admission[owner] !== id) return null;
+			const receipt = await control("rollback");
+			await admission.refresh();
+			return receipt;
+		},
+		run: start => async function* (input) {
+			if (!wrapped) { yield* start(input); return; }
+			await open();
+			let terminal, lost = false, finishError = null;
+			try {
+				for await (const frame of start(input)) {
+					if (frame.type === "tool.done" && !frame.ok && LOST_STUDIO.has(String(frame.error ?? "").split(":")[0])) lost = true;
+					if (frame.type === "done") terminal = frame; else yield frame;
+				}
+			} finally {
+				// Finish only the transaction this run opened (a rollback keeps it open).
+				if (admission[owner] === id) {
+					delete admission[owner];
+					const stopped = task && (signal?.aborted || input?.signal?.aborted);
+					if (!(task && (lost || task.lost))) {
+						try {
+							const receipt = await control(stopped ? "cancel" : "finish");
+							if (receipt.authored || task) yield { type: "receipt", receipt };
+						} catch (error) {
+							// The editor that held the task is gone: there is nothing left to finish.
+							if (!task || !LOST_STUDIO.has(error.code)) finishError = error;
+						}
+					}
+				}
+			}
+			if (finishError) throw finishError;
+			if (terminal) yield terminal;
+		},
+	};
+}

package/bin/cozyclay.mjs

@@ -147,9 +147,7 @@ const HELP = `cozyclay - browser-based 3D staging studio
   cclay update              install the latest cozyclay globally (npm install -g)
   npx cozyclay --port 5200  serve on another port
   npx cozyclay --no-open    do not open a browser
-  npx cozyclay --scene city-block
-                            open the studio on a bundled starter scene
-                            (the set from the cozyclay.org tutorial)
+  npx cozyclay --scene <id> open the studio on a bundled starter scene
   npx cozyclay --no-star    never ask about starring the repo
   npx cozyclay --no-update-check
                             do not look for a newer release
@@ -483,11 +481,11 @@ server.listen({ port: opts.port, host: "127.0.0.1", ipv6Only: false }, () => {
 	// The package exists to open the studio, which the site serves from /app/.
 	// Landing on "/" would greet someone who just typed `npx cozyclay` with a
 	// marketing page.
-	// --scene <id> continues from a bundled starter scene (the landing-page
-	// tutorial hands people this exact command). Only a bare id is accepted
-	// here; the studio resolves it to dist/scenes/<id>.cclayproject.
+	// --scene <id> opens a bundled starter scene. Only a bare id is accepted
+	// here; the studio resolves it to dist/scenes/<id>.cclayproject and ignores
+	// an id it does not ship, with a console warning.
 	const sceneParam = opts.scene && /^[a-z0-9-]+$/i.test(opts.scene) ? `?scene=${encodeURIComponent(opts.scene)}` : "";
-	if (opts.scene && !sceneParam) console.error(`cozyclay: --scene expects a starter id such as city-block (got ${opts.scene}); opening the studio without it.`);
+	if (opts.scene && !sceneParam) console.error(`cozyclay: --scene expects a bare starter id (got ${opts.scene}); opening the studio without it.`);
 	const url = `http://127.0.0.1:${opts.port}/app/${sceneParam}`;
 	console.log(`CozyClay is running at ${url}`);
 	console.log("Use a Chromium-based browser — Safari and Firefox are not supported.");

package/dist/app/index.html

@@ -34,14 +34,15 @@
     <title>CozyClay Studio — 3D staging and previs in your browser</title>
 
     <script defer src="https://static.cloudflareinsights.com/beacon.min.js" data-cf-beacon='{"token": "6a4384d1375d4ffc8a30a6346a8ad1a0"}'></script>
-    <script type="module" crossorigin src="/assets/app-DhRJ-PBz.js"></script>
+    <script type="module" crossorigin src="/assets/app-B2BpfCl2.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/rolldown-runtime-hePW80VL.js">
-    <link rel="modulepreload" crossorigin href="/assets/analytics-BibyE5ar.js">
-    <link rel="modulepreload" crossorigin href="/assets/first-shot-handoff-Qx7SKl38.js">
+    <link rel="modulepreload" crossorigin href="/assets/modulepreload-polyfill-P2Xu9kJm.js">
+    <link rel="modulepreload" crossorigin href="/assets/task-board-BKaM7d-9.js">
     <link rel="modulepreload" crossorigin href="/assets/fflate.module-KbGj5-H6.js">
-    <link rel="modulepreload" crossorigin href="/assets/scene-asset-sync-DBYQBR0T.js">
-    <link rel="stylesheet" crossorigin href="/assets/scene-asset-sync-_S8NQl5B.css">
-    <link rel="stylesheet" crossorigin href="/assets/app-f-fkV5uP.css">
+    <link rel="modulepreload" crossorigin href="/assets/scene-asset-sync-CQzEdsqu.js">
+    <link rel="modulepreload" crossorigin href="/assets/motion3-compile-B887n77J.js">
+    <link rel="stylesheet" crossorigin href="/assets/scene-asset-sync-COGOlF5T.css">
+    <link rel="stylesheet" crossorigin href="/assets/app-BlwOpest.css">
   </head>
   <body>
     <div id="root">

package/dist/assets/TaskBoard-DdDXMgZm.js

@@ -0,0 +1 @@
+import{r as e}from"./rolldown-runtime-hePW80VL.js";import{Pr as t,c as n,d as r,f as i,l as a,m as o,o as s,v as c,xi as l}from"./task-board-BKaM7d-9.js";import{o as u,r as d,t as f}from"./motion3-compile-B887n77J.js";var p=e(l(),1),m=2e3,h=(e,t)=>new Promise(n=>{let r=setTimeout(n,e);t.addEventListener(`abort`,()=>{clearTimeout(r),n()},{once:!0})});function g(e,n){(0,p.useEffect)(()=>{let r=new Map;for(let[t,i]of Object.entries(e))for(let e of i)r.set(e,n[t]??t);let i=()=>{for(let e of document.querySelectorAll(`[data-node-id]`)){let n=r.get(e.getAttribute(`data-node-id`));n?(e.setAttribute(`data-task-scope`,n),e.setAttribute(`title`,t(`In task: ${n}`,`작업 중: ${n}`))):e.hasAttribute(`data-task-scope`)&&(e.removeAttribute(`data-task-scope`),e.removeAttribute(`title`))}};i();let a=new MutationObserver(i);return a.observe(document.body,{childList:!0,subtree:!0}),()=>{a.disconnect(),r.clear(),i()}},[e,n])}function _({sessionId:e,pulse:t,labelOf:l,onMainNote:_}){let v=(0,p.useMemo)(()=>s(),[]),y=u(),[b,x]=(0,p.useReducer)((e,t)=>t.seed?o(e,t.seed):t.reset?n():r(e,t.event),void 0,n),[S,C]=(0,p.useState)({}),[w,T]=(0,p.useState)(f),E=(0,p.useRef)(0),D=(0,p.useRef)(_);(0,p.useEffect)(()=>{E.current=b.after,D.current=_},[b.after,_]),(0,p.useEffect)(()=>{x({reset:!0}),E.current=0},[e]),(0,p.useEffect)(()=>d(T),[]),(0,p.useEffect)(()=>y.subscribe(e=>{typeof e?.type!=`string`||!e.type.startsWith(`task.`)||(C(t=>i(t,e)),(e.type===`task.userEdit`||e.type===`task.undone`)&&x({event:e}))}),[y]),(0,p.useEffect)(()=>{if(!e)return;let t=new AbortController;return(async()=>{for(;!t.signal.aborted;){try{let{tasks:n}=await v.board(e);x({seed:n}),await v.events(e,E.current,e=>{if(e.type===`main.turn`&&e.turnId){let n=``;v.frames(e.turnId,e=>{e.type===`text.delta`&&(n+=e.text??``),e.type===`tool.start`&&(n=``)},t.signal).then(()=>D.current?.(n),()=>{})}x({event:e})},t.signal)}catch{}await h(m,t.signal)}})(),()=>t.abort()},[v,e,t]);let O=b.order.filter(e=>b.tasks[e]?.status===`running`&&b.tasks[e]?.turnId),k=O.map(e=>`${e}:${b.tasks[e].turnId}`).join();return(0,p.useEffect)(()=>{let e=O.map(e=>{let t=new AbortController,{turnId:n}=b.tasks[e];return v.frames(n,t=>{let n=a(t,l);n&&x({event:{type:`task.progress`,taskId:e,status:`running`,progress:n}})},t.signal).catch(()=>{}),t});return()=>e.forEach(e=>e.abort())},[v,k,l]),g(S,(0,p.useMemo)(()=>Object.fromEntries(b.order.map(e=>[e,b.tasks[e].title])),[b])),(0,p.useEffect)(()=>{c.set({client:v,labelOf:l,undo:async e=>{let t=await y.run(`task.undo`,{taskId:e});if(t?.ok===!1)throw Error(t.message??t.code);x({event:{type:`task.undone`,taskId:e}})}})},[y,v,l]),(0,p.useEffect)(()=>{c.set({board:b,activity:w})},[b,w]),(0,p.useEffect)(()=>()=>c.set({board:n(),open:null}),[e]),null}export{_ as default};