loopable-cli 0.1.0

package/.output/server/_ssr/tasks-vcoodp_D.mjs

@@ -0,0 +1,533 @@
+import { f as eq, u as desc } from "../_libs/drizzle-orm.mjs";
+import { c as loops, d as runDir, g as tasks, s as db } from "./client-CKkOfh-s.mjs";
+import { a as connectorManifest, c as credentialForConnector, i as connectorAction, o as connectorRuntime, s as connectorWorkflow } from "./connections-qnw2GVlP.mjs";
+import { o as settingsFor } from "./agents-Btql102J.mjs";
+import "./runners-DtXs4Q8a.mjs";
+import { randomUUID } from "node:crypto";
+import { existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { isAbsolute, join } from "node:path";
+//#region node_modules/.nitro/vite/services/ssr/assets/tasks-vcoodp_D.js
+/** The agent says this when the honest answer is silence. */
+var AGENT_NOTHING = "NOTHING_TO_DO";
+function isAgentNothing(text) {
+	const compact = (value) => value.replace(/[`*_.\s]/g, "").toUpperCase();
+	return compact(text) === compact(AGENT_NOTHING);
+}
+/**
+* Folder jobs name a path that only exists on Loopable's host.
+* A runner on another hostname cannot see that folder.
+*/
+function jobRequiresHost(job) {
+	return Boolean(job.cwd);
+}
+/**
+* Appended to the workflow's prompt, because the shape of the answer is the
+* machinery's business and the workflow should only have to describe the job.
+*/
+var REVIEW_FORMAT = [
+	`Reply with one JSON object and nothing else, in this shape:`,
+	``,
+	`{`,
+	`  "summary": "a few sentences on the change as a whole",`,
+	`  "findings": [`,
+	`    { "path": "src/thing.ts", "line": 42, "body": "what is wrong, and what to do" },`,
+	`    { "path": "src/thing.ts", "startLine": 60, "line": 64, "body": "for a point about several lines" }`,
+	`  ]`,
+	`}`,
+	``,
+	`- "path" is the path of the file in the repository.`,
+	`- "line" is the line number in the new version of the file. Only comment on`,
+	`  lines that this pull request changed; a comment on a line that is not in`,
+	`  the diff will be moved into the summary instead of attached.`,
+	`- One finding per point, placed where a reader has to look rather than where`,
+	`  you happened to notice it.`,
+	`- "body" is markdown with no heading.`,
+	`- "findings" may be empty when the summary says everything worth saying.`
+].join("\n");
+/**
+* Everything in the reply that might be the object, best first.
+*
+* More than one is offered on purpose. A streamed answer can arrive twice,
+* once in pieces and once whole, and a reply can carry an example alongside
+* the real thing, so the first block that looks like JSON is not reliably the
+* one that is. Each is tried in turn and the first that parses wins.
+*/
+function jsonCandidates(text) {
+	const fences = (pattern) => [...text.matchAll(pattern)].map((match) => (match[1] ?? "").trim()).filter(Boolean);
+	const labelled = fences(/```json\s*\n([\s\S]*?)```/gi);
+	const rest = fences(/```\s*\n([\s\S]*?)```/g);
+	const start = text.indexOf("{");
+	const end = text.lastIndexOf("}");
+	if (start !== -1 && end > start) rest.push(text.slice(start, end + 1));
+	return {
+		labelled,
+		rest
+	};
+}
+function answerFrom(json) {
+	let parsed;
+	try {
+		parsed = JSON.parse(json);
+	} catch {
+		return null;
+	}
+	if (typeof parsed !== "object" || parsed === null) return null;
+	const value = parsed;
+	const summary = typeof value.summary === "string" ? value.summary.trim() : "";
+	const findings = Array.isArray(value.findings) ? value.findings.flatMap((entry) => {
+		const finding = findingFrom(entry);
+		return finding ? [finding] : [];
+	}) : [];
+	return summary || findings.length > 0 ? {
+		summary,
+		findings
+	} : null;
+}
+function findingFrom(value) {
+	if (typeof value !== "object" || value === null) return null;
+	const entry = value;
+	const path = typeof entry.path === "string" ? entry.path.trim() : "";
+	const line = typeof entry.line === "number" ? Math.trunc(entry.line) : NaN;
+	const body = typeof entry.body === "string" ? entry.body.trim() : "";
+	if (!path || !body || !Number.isFinite(line) || line < 1) return null;
+	const start = typeof entry.startLine === "number" ? Math.trunc(entry.startLine) : void 0;
+	return {
+		path,
+		line,
+		...start !== void 0 && start >= 1 && start < line ? { startLine: start } : {},
+		body
+	};
+}
+/**
+* Lenient about the wrapper and strict about the contents.
+*
+* An agent that answered in prose is taken at its word and gets a review with
+* no anchors, which is what Loopable did before it could anchor anything. An
+* agent that plainly meant to answer in JSON, by fencing it as such, and
+* produced nothing readable is an error: the alternative is posting the
+* wreckage to somebody's pull request.
+*/
+function parseReview(text) {
+	const { labelled, rest } = jsonCandidates(text);
+	for (const candidate of [...labelled, ...rest]) {
+		const answer = answerFrom(candidate);
+		if (answer) return answer;
+	}
+	if (labelled.length > 0) throw new Error("The agent was asked for JSON and produced something that could not be read.");
+	const summary = text.trim();
+	if (!summary) throw new Error("The agent's answer was empty.");
+	return {
+		summary,
+		findings: []
+	};
+}
+/**
+* Splits findings into the ones that can be attached to a line and the ones
+* that cannot. With nothing to check against, everything is treated as
+* unanchorable: guessing would risk the whole review being refused.
+*/
+function anchorFindings(findings, commentable) {
+	const comments = [];
+	const loose = [];
+	for (const finding of findings) {
+		const lines = commentable?.[finding.path];
+		const allowed = lines ? new Set(lines) : null;
+		(allowed !== null && allowed.has(finding.line) && (finding.startLine === void 0 || allowed.has(finding.startLine)) ? comments : loose).push(finding);
+	}
+	return {
+		comments,
+		loose
+	};
+}
+/** The review body: the overview, then anything that could not be anchored. */
+function reviewBody(summary, loose) {
+	const parts = summary ? [summary] : [];
+	for (const finding of loose) {
+		const at = finding.startLine ? `${finding.startLine}-${finding.line}` : String(finding.line);
+		parts.push(`**${finding.path}:${at}**\n\n${finding.body}`);
+	}
+	return parts.join("\n\n");
+}
+/**
+* The branch name a code-writing task uses, so a retry pushes the same branch
+* the first attempt made rather than leaving a trail of near-identical ones.
+*/
+/** Reads as a branch name and cannot collide with a person's own. */
+function slug(text) {
+	return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "work";
+}
+function branchFor(input) {
+	return `loopable/${slug(input.ref)}-${input.taskId.slice(0, 8)}`;
+}
+/**
+* The agent says this when the honest answer is "nothing". Without it a loop
+* that runs by itself would post filler, which is worse than silence.
+*/
+var NOTHING = AGENT_NOTHING;
+/**
+* The answer is the checkout, not the reply, so the reply is asked for as the
+* account somebody reads before deciding whether to look at the diff.
+*/
+var CODE_FORMAT = [
+	"Then reply with the description of a pull request: a first line under about",
+	"seventy characters saying what it does, a blank line, and a short account of",
+	"what you changed and anything you were unsure about. No preamble."
+].join("\n");
+function toView(row) {
+	return {
+		id: row.id,
+		loopId: row.loopId,
+		loopName: row.loopName ?? "Deleted loop",
+		connectorId: row.connectorId,
+		state: row.state,
+		sourceUrl: row.sourceUrl,
+		sourceKind: row.sourceKind,
+		sourceRef: row.sourceRef,
+		sourceTitle: row.sourceTitle,
+		dryRun: row.dryRun,
+		agentId: row.agentId,
+		runnerId: row.runnerId,
+		agentCommand: row.agentCommand,
+		output: row.output,
+		comments: row.comments ?? [],
+		actionConnectorId: row.actionConnectorId,
+		actionId: row.actionId,
+		resultUrl: row.resultUrl,
+		error: row.error,
+		attempts: row.attempts,
+		cancelRequested: row.cancelRequested,
+		durationMs: row.durationMs,
+		createdAt: row.createdAt.toISOString(),
+		startedAt: row.startedAt?.toISOString() ?? null,
+		updatedAt: row.updatedAt.toISOString()
+	};
+}
+function select() {
+	return db().select({
+		id: tasks.id,
+		loopId: tasks.loopId,
+		connectorId: tasks.connectorId,
+		state: tasks.state,
+		sourceUrl: tasks.sourceUrl,
+		sourceKind: tasks.sourceKind,
+		sourceRef: tasks.sourceRef,
+		sourceTitle: tasks.sourceTitle,
+		dryRun: tasks.dryRun,
+		agentId: tasks.agentId,
+		runnerId: tasks.runnerId,
+		agentCommand: tasks.agentCommand,
+		output: tasks.output,
+		comments: tasks.comments,
+		actionConnectorId: tasks.actionConnectorId,
+		actionId: tasks.actionId,
+		actionTarget: tasks.actionTarget,
+		resultUrl: tasks.resultUrl,
+		error: tasks.error,
+		logPath: tasks.logPath,
+		logText: tasks.logText,
+		attempts: tasks.attempts,
+		runAfter: tasks.runAfter,
+		leaseUntil: tasks.leaseUntil,
+		cancelRequested: tasks.cancelRequested,
+		dedupeKey: tasks.dedupeKey,
+		durationMs: tasks.durationMs,
+		createdAt: tasks.createdAt,
+		startedAt: tasks.startedAt,
+		updatedAt: tasks.updatedAt,
+		loopName: loops.name
+	}).from(tasks).leftJoin(loops, eq(tasks.loopId, loops.id));
+}
+async function listTasks(options = {}) {
+	const query = select().orderBy(desc(tasks.createdAt)).limit(options.limit ?? 100);
+	return (options.loopId ? await query.where(eq(tasks.loopId, options.loopId)).all() : await query.all()).map(toView);
+}
+async function getTask(id) {
+	const row = await select().where(eq(tasks.id, id)).get();
+	return row ? toView(row) : null;
+}
+async function taskRow(id) {
+	return await db().select().from(tasks).where(eq(tasks.id, id)).get();
+}
+async function updateTask(id, values) {
+	await db().update(tasks).set({
+		...values,
+		updatedAt: /* @__PURE__ */ new Date()
+	}).where(eq(tasks.id, id)).run();
+}
+/** The one place a task is created, whether a person or a poll asked for it. */
+async function queue(input) {
+	const id = randomUUID();
+	await db().insert(tasks).values({
+		id,
+		loopId: input.loop.id,
+		connectorId: input.loop.connectorId,
+		state: "queued",
+		sourceUrl: input.url.trim(),
+		sourceKind: input.item.kind,
+		sourceRef: input.item.ref,
+		sourcePayload: input.payload,
+		sourceTitle: input.title,
+		dryRun: input.dryRun,
+		actionConnectorId: input.loop.actionConnectorId,
+		actionId: input.loop.actionId,
+		actionTarget: input.loop.actionTarget,
+		dedupeKey: input.dedupeKey
+	}).run();
+	return await getTask(id);
+}
+/** Everything a loop needs before it can produce a task, or a reason it cannot. */
+async function runnable(loopId) {
+	const loop = await db().select().from(loops).where(eq(loops.id, loopId)).get();
+	if (!loop) throw new Error("Loop not found");
+	const manifest = connectorManifest(loop.connectorId);
+	if (!manifest) throw new Error(`Unknown connector: ${loop.connectorId}`);
+	if (!connectorWorkflow(loop.connectorId, loop.workflowId)) throw new Error(`${manifest.name} no longer offers the workflow this loop was built on.`);
+	if (!connectorRuntime(loop.connectorId).resolveWorkItem) throw new Error(`${manifest.name} cannot run tasks yet.`);
+	const writer = connectorManifest(loop.actionConnectorId);
+	if (!writer) throw new Error(`Unknown connector: ${loop.actionConnectorId}`);
+	if (!connectorRuntime(loop.actionConnectorId).applyAction) throw new Error(`${writer.name} cannot write anything yet.`);
+	return loop;
+}
+/**
+* Queues a run and returns at once. Identifying the link needs no network, so
+* a typo still fails while the person is looking at the box, but everything
+* that can be slow or can fail belongs to the dispatcher.
+*/
+async function enqueueTask(input) {
+	const loop = await runnable(input.loopId);
+	const manifest = connectorManifest(loop.connectorId);
+	const runtime = connectorRuntime(loop.connectorId);
+	if (manifest.byHand.kind === "now" && runtime.itemForNow) return await queue({
+		loop,
+		item: runtime.itemForNow(),
+		url: "",
+		dryRun: input.dryRun
+	});
+	if (!runtime.identifyLink) throw new Error(`${manifest.name} cannot read links.`);
+	const item = runtime.identifyLink(input.url);
+	if (!item) throw new Error(`That does not look like a ${manifest.name} link Loopable can work on.`);
+	return await queue({
+		loop,
+		item,
+		url: input.url,
+		dryRun: input.dryRun
+	});
+}
+/**
+* Queues a run for something a poll noticed. The title is already known, so
+* the inbox can say what the task is about before the dispatcher has fetched
+* anything.
+*/
+async function enqueueSignal(input) {
+	const loop = await runnable(input.loop.id);
+	return await queue({
+		loop,
+		item: input.signal,
+		payload: input.signal.payload,
+		url: input.signal.url,
+		title: input.signal.title,
+		dryRun: false,
+		dedupeKey: `${loop.id}:${input.signal.key}`
+	});
+}
+/** The tail is what matters while a run is going; the whole thing rarely is. */
+var LOG_TAIL_BYTES = 64e3;
+async function readTaskLog(id) {
+	const task = await taskRow(id);
+	if (!task) return null;
+	let text = task.logText;
+	if (!text && task.logPath && existsSync(task.logPath)) text = readFileSync(task.logPath, "utf8");
+	if (!text) return null;
+	if (text.length <= LOG_TAIL_BYTES) return text;
+	return `[earlier output not shown]\n\n${text.slice(-64e3)}`;
+}
+async function requestCancel(id) {
+	if (!await taskRow(id)) return null;
+	await updateTask(id, { cancelRequested: true });
+	return await getTask(id);
+}
+var TaskCancelled = class extends Error {
+	constructor() {
+		super("Stopped before it finished.");
+		this.name = "Cancelled";
+	}
+};
+/**
+* The directory a loop says its agent should work in. Checked here rather than
+* left to the agent, which would otherwise run somewhere unexpected and answer
+* confidently about the wrong code.
+*/
+function folderFor(loop) {
+	const folder = typeof loop.settings.folder === "string" ? loop.settings.folder.trim() : "";
+	if (!folder) throw new Error("This loop has no folder set. Set one and try again.");
+	if (!isAbsolute(folder)) throw new Error(`The folder must be an absolute path: ${folder}`);
+	if (!existsSync(folder)) throw new Error(`There is no folder at ${folder}.`);
+	if (!statSync(folder).isDirectory()) throw new Error(`${folder} is not a folder.`);
+	return folder;
+}
+var KIND_NOUN = {
+	pull_request: "pull request",
+	issue: "issue",
+	message: "the message",
+	email: "the email",
+	occurrence: "the run due at"
+};
+function checkoutInstructions(item, branch, writesCode) {
+	const checkout = item.checkout;
+	if (!checkout) return [];
+	const at = checkout.sha ? `${checkout.ref} (${checkout.sha})` : checkout.ref;
+	if (writesCode && branch) return [
+		`Clone ${checkout.url} and check out ${at}.`,
+		`Commit your change and push it to ${branch}. Do not open a pull request; Loopable will.`,
+		``
+	];
+	return [`Clone ${checkout.url} and check out ${at}. Work in that checkout. Do not commit or push.`, ``];
+}
+/**
+* What the agent is actually sent.
+*
+* The loop supplies the job and, if it has anything to add, its guidance after
+* it. What shape the answer must take is not either of theirs: it is what the
+* code downstream is able to read, so it is appended here and neither of them
+* has to know about it.
+*/
+function promptFor(input) {
+	const shape = input.workflow.answer === "review" ? [REVIEW_FORMAT] : input.workflow.answer === "code" ? [CODE_FORMAT] : [`Reply with only the text to post. No preamble, no explanation of what you are about to do.`];
+	return [
+		`You are working on ${KIND_NOUN[input.item.kind]} ${input.item.ref}.`,
+		...input.files.length > 0 ? [`Read ${input.files.join(" and ")} first.`] : [],
+		``,
+		...checkoutInstructions(input.item, input.branch, input.workflow.answer === "code"),
+		`Your task:`,
+		input.ask,
+		...input.guidance ? [
+			``,
+			`From the person who set this up:`,
+			input.guidance
+		] : [],
+		``,
+		...shape,
+		``,
+		`If there is genuinely nothing worth posting, reply with exactly ${NOTHING}.`
+	].join("\n");
+}
+/**
+* Turns what the agent said into what will be posted. A review is parsed and
+* its findings checked against the diff; anything that cannot be attached to a
+* line goes into the body with its location written out, because losing the
+* point is worse than losing its position.
+*/
+function answerFor(workflow, action, item, text) {
+	if (workflow.answer !== "review") return {
+		output: text,
+		comments: []
+	};
+	const { summary, findings } = parseReview(text);
+	const { comments, loose } = action.accepts.includes("review") ? anchorFindings(findings, item.commentable) : {
+		comments: [],
+		loose: findings
+	};
+	return {
+		output: reviewBody(summary, loose) || "Comments are on the lines they are about.",
+		comments
+	};
+}
+async function loadWork(id, signal) {
+	const task = await taskRow(id);
+	if (!task) throw new Error(`Task not found: ${id}`);
+	if (signal?.aborted || task.cancelRequested) throw new TaskCancelled();
+	const loop = await db().select().from(loops).where(eq(loops.id, task.loopId)).get();
+	if (!loop) throw new Error("The loop behind this task has been deleted.");
+	const workflow = connectorWorkflow(loop.connectorId, loop.workflowId);
+	if (!workflow) throw new Error(`${loop.connectorId} no longer offers ${loop.workflowId}.`);
+	const runtime = connectorRuntime(task.connectorId);
+	if (!runtime.resolveWorkItem) throw new Error(`${task.connectorId} cannot run tasks.`);
+	const writer = connectorRuntime(task.actionConnectorId);
+	if (!writer.applyAction) throw new Error(`${task.actionConnectorId} cannot write anything.`);
+	const action = connectorAction(task.actionConnectorId, task.actionId);
+	if (!action) throw new Error(`${task.actionConnectorId} no longer offers ${task.actionId}.`);
+	const { credential } = await credentialForConnector(task.connectorId);
+	return {
+		task,
+		loop,
+		workflow,
+		writer,
+		action,
+		credential,
+		item: await runtime.resolveWorkItem({
+			url: task.sourceUrl,
+			payload: task.sourcePayload ?? null,
+			credential
+		})
+	};
+}
+async function jobForTask(id) {
+	const { task, loop, workflow, item } = await loadWork(id);
+	if (!task.agentId) throw new Error("This task has no agent yet.");
+	const workspace = runDir(id);
+	const cwd = workflow.runsIn === "folder" ? folderFor(loop) : void 0;
+	const branch = workflow.answer === "code" ? branchFor({
+		ref: item.ref,
+		taskId: id
+	}) : void 0;
+	const settings = { ...await settingsFor(task.agentId) };
+	if (item.checkout && settings.permissionMode === "read_only") settings.permissionMode = "workspace_write";
+	return {
+		taskId: id,
+		agentId: task.agentId,
+		prompt: promptFor({
+			workflow,
+			ask: loop.prompt,
+			guidance: loop.guidance,
+			item,
+			files: item.context.map((file) => cwd ? join(workspace, file.name) : file.name),
+			branch
+		}),
+		settings,
+		files: item.context.map((file) => ({
+			name: file.name,
+			body: file.body
+		})),
+		...cwd ? { cwd } : {}
+	};
+}
+async function absorbAgentOutput(id, raw) {
+	const { task, workflow, action, item } = await loadWork(id);
+	const workspace = runDir(id);
+	const said = raw.trim();
+	writeFileSync(join(workspace, "reply.txt"), said);
+	if (!said) throw new Error("The agent produced nothing.");
+	if (isAgentNothing(said)) {
+		await finish(id, task, {
+			state: "skipped",
+			output: said
+		});
+		return await getTask(id);
+	}
+	const parsed = answerFor(workflow, action, item, said);
+	if (!parsed.output && parsed.comments.length === 0) throw new Error("The agent produced nothing worth posting.");
+	await updateTask(id, {
+		output: parsed.output,
+		comments: parsed.comments
+	});
+	if (task.dryRun) {
+		await finish(id, task, { state: "prepared" });
+		return await getTask(id);
+	}
+	await updateTask(id, {
+		state: "applying",
+		leaseUntil: null
+	});
+	return await getTask(id);
+}
+async function finish(id, task, values) {
+	const started = task.startedAt?.getTime() ?? task.createdAt.getTime();
+	await updateTask(id, {
+		error: null,
+		...values,
+		durationMs: Date.now() - started,
+		leaseUntil: null
+	});
+}
+//#endregion
+export { jobForTask as a, readTaskLog as c, updateTask as d, getTask as i, requestCancel as l, enqueueSignal as n, jobRequiresHost as o, enqueueTask as r, listTasks as s, absorbAgentOutput as t, taskRow as u };

package/.output/server/_tanstack-start-manifest_v-C0cP5F0M.mjs

@@ -0,0 +1,125 @@
+//#region node_modules/.nitro/vite/services/ssr/assets/_tanstack-start-manifest_v-C0cP5F0M.js
+var tsrStartManifest = () => ({ routes: {
+	__root__: {
+		filePath: "/Users/bytedance/codex-projects/loopable/src/routes/__root.tsx",
+		children: [
+			"/",
+			"/connectors/$connectorId",
+			"/inbox/$taskId",
+			"/loops/$loopId",
+			"/loops/new",
+			"/agents/",
+			"/connectors/",
+			"/inbox/",
+			"/loops/",
+			"/machines/",
+			"/runners/",
+			"/api/runners/claim",
+			"/api/runners/heartbeat",
+			"/api/runners/hello",
+			"/api/connectors/$connectorId/authorize",
+			"/api/connectors/$connectorId/callback",
+			"/api/runners/jobs/$taskId/complete",
+			"/api/runners/jobs/$taskId/log"
+		],
+		preloads: [
+			"/assets/index-ztzex0FN.js",
+			"/assets/preload-helper-ORbuV86A.js",
+			"/assets/button-HCY6DCY-.js",
+			"/assets/tasks-B8MsKgic.js",
+			"/assets/manifests-DNMqf7Vi.js",
+			"/assets/connectors-BvzttfSu.js",
+			"/assets/loops-oSdqMd29.js"
+		],
+		scripts: [{ attrs: {
+			type: "module",
+			async: !0,
+			src: "/assets/index-ztzex0FN.js"
+		} }]
+	},
+	"/connectors/$connectorId": {
+		filePath: "/Users/bytedance/codex-projects/loopable/src/routes/connectors/$connectorId.tsx",
+		children: void 0,
+		preloads: [
+			"/assets/_connectorId-BWjYn5tm.js",
+			"/assets/arrow-left-BF9juV9T.js",
+			"/assets/connector-icon-BZ_MUJV_.js",
+			"/assets/external-link-D46X-bXa.js",
+			"/assets/loader-CcBl2u8m.js",
+			"/assets/trash-2-D6u6NpzO.js",
+			"/assets/setting-fields-ixkpdBb-.js",
+			"/assets/connection-status-CYZB8kLy.js",
+			"/assets/alert-Bn9-Zm0l.js"
+		]
+	},
+	"/inbox/$taskId": {
+		filePath: "/Users/bytedance/codex-projects/loopable/src/routes/inbox/$taskId.tsx",
+		children: void 0,
+		preloads: [
+			"/assets/_taskId-BOzICXDf.js",
+			"/assets/arrow-left-BF9juV9T.js",
+			"/assets/task-list-BpOStt9v.js",
+			"/assets/external-link-D46X-bXa.js",
+			"/assets/loader-CcBl2u8m.js",
+			"/assets/alert-Bn9-Zm0l.js"
+		]
+	},
+	"/loops/$loopId": {
+		filePath: "/Users/bytedance/codex-projects/loopable/src/routes/loops/$loopId.tsx",
+		children: void 0,
+		preloads: [
+			"/assets/_loopId-Ds4RkyEc.js",
+			"/assets/arrow-left-BF9juV9T.js",
+			"/assets/loop-form-dB3CLcZb.js",
+			"/assets/task-list-BpOStt9v.js",
+			"/assets/switch-d5ummmHY.js",
+			"/assets/alert-Bn9-Zm0l.js",
+			"/assets/gaps-D-I6xiDc.js"
+		]
+	},
+	"/loops/new": {
+		filePath: "/Users/bytedance/codex-projects/loopable/src/routes/loops/new.tsx",
+		children: void 0,
+		preloads: [
+			"/assets/new-uyFxVjuB.js",
+			"/assets/arrow-left-BF9juV9T.js",
+			"/assets/arrow-right-CzqvnOY1.js",
+			"/assets/loop-form-dB3CLcZb.js",
+			"/assets/connector-icon-BZ_MUJV_.js"
+		]
+	},
+	"/connectors/": {
+		filePath: "/Users/bytedance/codex-projects/loopable/src/routes/connectors/index.tsx",
+		children: void 0,
+		preloads: [
+			"/assets/connectors-DdJNwRN_.js",
+			"/assets/arrow-right-CzqvnOY1.js",
+			"/assets/connector-icon-BZ_MUJV_.js",
+			"/assets/connection-status-CYZB8kLy.js"
+		]
+	},
+	"/inbox/": {
+		filePath: "/Users/bytedance/codex-projects/loopable/src/routes/inbox/index.tsx",
+		children: void 0,
+		preloads: ["/assets/inbox-BUUu9xxE.js", "/assets/task-list-BpOStt9v.js"]
+	},
+	"/loops/": {
+		filePath: "/Users/bytedance/codex-projects/loopable/src/routes/loops/index.tsx",
+		children: void 0,
+		preloads: [
+			"/assets/loops-DRunQrxL.js",
+			"/assets/connector-icon-BZ_MUJV_.js",
+			"/assets/trash-2-D6u6NpzO.js",
+			"/assets/switch-d5ummmHY.js",
+			"/assets/alert-Bn9-Zm0l.js",
+			"/assets/gaps-D-I6xiDc.js"
+		]
+	},
+	"/runners/": {
+		filePath: "/Users/bytedance/codex-projects/loopable/src/routes/runners/index.tsx",
+		children: void 0,
+		preloads: ["/assets/runners-DSU3r5Ww.js", "/assets/alert-Bn9-Zm0l.js"]
+	}
+} });
+//#endregion
+export { tsrStartManifest };