@cleocode/cleo 2026.10.2 → 2026.10.4

package/dist/cli/workgraph-FXBSZDQE.js

@@ -0,0 +1,232 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import "./chunk-C3B7C43W.js";
+import {
+  defineCommand,
+  showUsage
+} from "./chunk-PKKZPOOP.js";
+
+// packages/cleo/src/cli/commands/workgraph.ts
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+var validateCommand = defineCommand({
+  meta: {
+    name: "validate",
+    description: "Validate a WorkGraph scaffold JSON payload (dry-run)"
+  },
+  args: {
+    file: {
+      type: "positional",
+      description: "Path to scaffold JSON file",
+      required: true
+    }
+  },
+  async run({ args }) {
+    const { validateWorkGraphScaffold } = await import("@cleocode/core/workgraph");
+    const { cliOutput } = await import("./renderers-64OR3IWX.js");
+    const filePath = resolve(String(args.file));
+    let raw;
+    try {
+      raw = readFileSync(filePath, "utf-8");
+    } catch {
+      cliOutput(
+        { error: `Cannot read file: ${filePath}` },
+        { command: "workgraph", operation: "validate" }
+      );
+      return;
+    }
+    let payload;
+    try {
+      payload = JSON.parse(raw);
+    } catch {
+      cliOutput(
+        { error: `Invalid JSON in ${filePath}` },
+        { command: "workgraph", operation: "validate" }
+      );
+      return;
+    }
+    const result = validateWorkGraphScaffold(payload);
+    cliOutput(result, { command: "workgraph", operation: "validate" });
+  }
+});
+var applyCommand = defineCommand({
+  meta: {
+    name: "apply",
+    description: "Atomically apply a WorkGraph scaffold to the task database"
+  },
+  args: {
+    file: {
+      type: "positional",
+      description: "Path to scaffold JSON file",
+      required: true
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Validate only, do not write to the database",
+      required: false
+    }
+  },
+  async run({ args }) {
+    const { applyWorkGraphScaffold } = await import("@cleocode/core/workgraph");
+    const { cliOutput } = await import("./renderers-64OR3IWX.js");
+    const filePath = resolve(String(args.file));
+    let raw;
+    try {
+      raw = readFileSync(filePath, "utf-8");
+    } catch {
+      cliOutput(
+        { error: `Cannot read file: ${filePath}` },
+        { command: "workgraph", operation: "apply" }
+      );
+      return;
+    }
+    let payload;
+    try {
+      payload = JSON.parse(raw);
+    } catch {
+      cliOutput(
+        { error: `Invalid JSON in ${filePath}` },
+        { command: "workgraph", operation: "apply" }
+      );
+      return;
+    }
+    const result = await applyWorkGraphScaffold({ ...payload, apply: !args["dry-run"] });
+    cliOutput(result, { command: "workgraph", operation: "apply" });
+  }
+});
+var planCommand = defineCommand({
+  meta: {
+    name: "plan",
+    description: "Generate a planning doc from a Saga WorkGraph"
+  },
+  args: {
+    sagaId: {
+      type: "positional",
+      description: "Saga task ID to generate the plan for",
+      required: true
+    },
+    audience: {
+      type: "string",
+      description: "Audience: agent (compact) or maintainer (prose)",
+      required: false,
+      default: "maintainer"
+    }
+  },
+  async run({ args }) {
+    const { generatePlanningDoc } = await import("@cleocode/core/workgraph");
+    const { getProjectRoot } = await import("@cleocode/core");
+    const { cliOutput } = await import("./renderers-64OR3IWX.js");
+    const projectRoot = getProjectRoot();
+    const audience = String(args.audience) === "agent" ? "agent" : "maintainer";
+    const result = await generatePlanningDoc(projectRoot, {
+      sagaId: String(args.sagaId),
+      audience
+    });
+    cliOutput(result, { command: "workgraph", operation: "plan" });
+  }
+});
+var structureCommand = defineCommand({
+  meta: {
+    name: "structure",
+    description: "Validate WorkGraph structure (cycles, depth violations, orphans)"
+  },
+  async run() {
+    const { validateWorkGraphStructure } = await import("@cleocode/core/workgraph");
+    const { taskList } = await import("@cleocode/core/internal");
+    const { getProjectRoot } = await import("@cleocode/core");
+    const { cliOutput } = await import("./renderers-64OR3IWX.js");
+    const projectRoot = getProjectRoot();
+    const listResult = await taskList(projectRoot, { limit: 5e3 });
+    const tasks = listResult.success ? listResult.data?.tasks ?? [] : [];
+    const nodes = tasks.map((t) => ({
+      id: String(t.id ?? ""),
+      type: t.type ?? "task",
+      parentId: t.parentId ?? null,
+      phase: t.phase ?? null
+    }));
+    const result = validateWorkGraphStructure(nodes, {});
+    cliOutput(result, { command: "workgraph", operation: "structure" });
+  }
+});
+var statusCommand = defineCommand({
+  meta: {
+    name: "status",
+    description: "One-shot saga-to-saga workgraph dashboard (tracking checklist)"
+  },
+  async run() {
+    const { sagas, getProjectRoot } = await import("@cleocode/core");
+    const { cliOutput } = await import("./renderers-64OR3IWX.js");
+    const projectRoot = getProjectRoot();
+    const listResult = await sagas.sagaList(projectRoot);
+    if (!listResult.success) {
+      cliOutput(listResult, { command: "workgraph", operation: "workgraph.status" });
+      return;
+    }
+    const allSagas = listResult.data?.sagas ?? [];
+    const sagaMap = new Map(
+      allSagas.map((s) => [s.id, s])
+    );
+    const TERMINAL = /* @__PURE__ */ new Set(["done", "cancelled", "deleted", "archived", "completed"]);
+    const rows = [];
+    for (let i = 0; i < sagas.CANONICAL_SAGA_ORDER.length; i++) {
+      const [id, label] = sagas.CANONICAL_SAGA_ORDER[i];
+      const saga = sagaMap.get(id);
+      if (!saga) continue;
+      const status = saga.status ?? "pending";
+      const rollupResult = await sagas.sagaRollup(projectRoot, { sagaId: id });
+      const rollup = rollupResult.success ? rollupResult.data : { total: 0, done: 0, completionPct: 0 };
+      rows.push({
+        rank: i + 1,
+        sagaId: id,
+        status,
+        completionPct: rollup.completionPct ?? 0,
+        done: rollup.done ?? 0,
+        total: rollup.total ?? 0,
+        label: TERMINAL.has(status) ? `${label} \u2713` : label
+      });
+    }
+    cliOutput(
+      {
+        rows,
+        total: rows.length,
+        activeSagaCount: rows.filter((r) => !TERMINAL.has(r.status)).length
+      },
+      { command: "workgraph", operation: "workgraph.status" }
+    );
+  }
+});
+var workgraphCommand = defineCommand({
+  meta: {
+    name: "workgraph",
+    description: "PM-Core V2 WorkGraph operations \u2014 validate, apply, plan, structure, status"
+  },
+  subCommands: {
+    validate: validateCommand,
+    apply: applyCommand,
+    plan: planCommand,
+    structure: structureCommand,
+    status: statusCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  workgraphCommand
+};
+//# sourceMappingURL=workgraph-FXBSZDQE.js.map

package/dist/cli/worktree-6RXAJIST.js

@@ -0,0 +1,370 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  defineCommand,
+  showUsage
+} from "./chunk-PKKZPOOP.js";
+import {
+  dispatchFromCli
+} from "./chunk-3IOQVUO7.js";
+import "./chunk-AWCQH2W5.js";
+import "./chunk-OGV57L4J.js";
+import "./chunk-ZBISIPCK.js";
+import {
+  cliError,
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-QFFQSKRC.js";
+
+// packages/cleo/src/cli/commands/worktree.ts
+import readline from "node:readline";
+import { getProjectRoot, listWorktrees } from "@cleocode/core/internal";
+var VALID_STATUS_VALUES = ["active", "stale", "merged", "orphan", "locked"];
+var listCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "List worktrees attached to this project with status classification (active|stale|merged|orphan|locked)."
+  },
+  args: {
+    status: {
+      type: "string",
+      description: `Filter by status category (single value or comma-separated list of ${VALID_STATUS_VALUES.join("|")}).`
+    },
+    days: {
+      type: "string",
+      description: "Staleness threshold in days for the isStale classifier (default: 7)."
+    }
+  },
+  async run({ args }) {
+    const statusFilter = typeof args["status"] === "string" && args["status"].length > 0 ? args["status"] : void 0;
+    const staleDaysRaw = typeof args["days"] === "string" ? args["days"] : void 0;
+    const staleDays = staleDaysRaw !== void 0 ? Number.parseInt(staleDaysRaw, 10) : void 0;
+    await dispatchFromCli(
+      "query",
+      "worktree",
+      "list",
+      {
+        ...statusFilter !== void 0 ? { statusFilter } : {},
+        ...staleDays !== void 0 && !Number.isNaN(staleDays) ? { staleDays } : {}
+      },
+      { command: "worktree-list", operation: "worktree.list" }
+    );
+  }
+});
+async function promptYesNo(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(`${question} [y/N]: `, (answer) => {
+      rl.close();
+      const trimmed = answer.trim().toLowerCase();
+      resolve(trimmed === "y" || trimmed === "yes");
+    });
+  });
+}
+function renderOrphanPreamble(wt) {
+  return [
+    "Orphaned worktree found:",
+    `  Path: ${wt.path}`,
+    `  Branch: ${wt.branch}${wt.isMerged ? " (merged to main)" : ""}`,
+    `  Task status: ${wt.owningTaskStatus ?? "(missing)"}`,
+    `  Last activity: ${wt.lastActivity}`,
+    ""
+  ].join("\n");
+}
+var pruneCommand = defineCommand({
+  meta: {
+    name: "prune",
+    description: "Remove orphan/merged worktrees with per-orphan Y/N confirmation."
+  },
+  args: {
+    orphaned: {
+      type: "boolean",
+      description: "Prune worktrees classified as orphan or merged (required).",
+      default: false
+    },
+    yes: {
+      type: "boolean",
+      description: "Skip per-orphan confirmation. Required on non-TTY (CI / pipe) input.",
+      default: false
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Show what would be pruned without acting. No audit-log entries written.",
+      default: false
+    },
+    days: {
+      type: "string",
+      description: "Override staleness threshold passed through to the listing (default: 7)."
+    },
+    "idle-days": {
+      type: "string",
+      description: "Abandonment-timeout threshold in days (T9805 AC2). Worktrees whose last commit is older than this value AND have no open PR are also pruned."
+    }
+  },
+  async run({ args }) {
+    if (args["orphaned"] !== true) {
+      cliError(
+        "cleo worktree prune requires --orphaned (other categories are reserved for future flags).",
+        2
+      );
+      process.exit(2);
+      return;
+    }
+    const dryRun = args["dry-run"] === true;
+    const yes = args["yes"] === true;
+    const staleDaysRaw = typeof args["days"] === "string" ? args["days"] : void 0;
+    const staleDays = staleDaysRaw !== void 0 ? Number.parseInt(staleDaysRaw, 10) : void 0;
+    const idleDaysRaw = typeof args["idle-days"] === "string" ? args["idle-days"] : void 0;
+    const idleDays = idleDaysRaw !== void 0 ? Number.parseInt(idleDaysRaw, 10) : void 0;
+    const projectRoot = getProjectRoot();
+    const listResult = await listWorktrees({
+      projectRoot,
+      ...staleDays !== void 0 && !Number.isNaN(staleDays) ? { staleDays } : {}
+    });
+    if (!listResult.success) {
+      cliError(`Failed to enumerate worktrees: ${listResult.error.message}`, 1);
+      process.exit(1);
+      return;
+    }
+    const candidates = listResult.data.worktrees.filter(
+      (w) => w.statusCategory === "orphan" || w.statusCategory === "merged"
+    );
+    if (candidates.length === 0) {
+      cliOutput(
+        {
+          prunedCount: 0,
+          skippedCount: 0,
+          outcomes: [],
+          errors: [],
+          dryRun,
+          message: "No orphan or merged worktrees found."
+        },
+        { command: "worktree-prune", operation: "worktree.prune" }
+      );
+      return;
+    }
+    const isTty = process.stdin.isTTY === true;
+    if (!isTty && !yes && !dryRun) {
+      cliError(
+        "cleo worktree prune is interactive \u2014 re-run with --yes or --dry-run on non-TTY input.",
+        2
+      );
+      process.exit(2);
+      return;
+    }
+    let confirmedPaths;
+    let skippedByUser = 0;
+    if (dryRun || yes) {
+      confirmedPaths = candidates.map((w) => w.path);
+    } else {
+      confirmedPaths = [];
+      for (const wt of candidates) {
+        process.stdout.write(renderOrphanPreamble(wt));
+        const accepted = await promptYesNo("Prune this worktree?");
+        if (accepted) {
+          confirmedPaths.push(wt.path);
+        } else {
+          skippedByUser += 1;
+        }
+      }
+    }
+    if (confirmedPaths.length === 0) {
+      cliOutput(
+        {
+          prunedCount: 0,
+          skippedCount: skippedByUser,
+          outcomes: [],
+          errors: [],
+          dryRun,
+          message: skippedByUser > 0 ? `Skipped ${skippedByUser} orphan(s) on user request.` : "No-op."
+        },
+        { command: "worktree-prune", operation: "worktree.prune" }
+      );
+      return;
+    }
+    await dispatchFromCli(
+      "mutate",
+      "worktree",
+      "prune",
+      {
+        dryRun,
+        paths: confirmedPaths,
+        ...staleDays !== void 0 && !Number.isNaN(staleDays) ? { staleDays } : {},
+        ...idleDays !== void 0 && !Number.isNaN(idleDays) ? { idleDays } : {}
+      },
+      { command: "worktree-prune", operation: "worktree.prune" }
+    );
+  }
+});
+var destroyCommand = defineCommand({
+  meta: {
+    name: "destroy",
+    description: "Destroy the XDG worktree for a task, update audit log and sentinel index (T9805)."
+  },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "The task ID whose worktree to destroy (e.g. T9805).",
+      required: true
+    },
+    force: {
+      type: "boolean",
+      description: "Force removal even when the worktree has uncommitted changes.",
+      default: false
+    },
+    reason: {
+      type: "string",
+      description: "Reason string recorded in the audit log (e.g. pr-merged, manual, idle-timeout)."
+    },
+    "keep-branch": {
+      type: "boolean",
+      description: "Do not delete the task branch after removing the worktree.",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const rawTaskId = typeof args["taskId"] === "string" ? args["taskId"] : "";
+    if (rawTaskId.length === 0) {
+      cliError("Missing required positional: <taskId>.", 2);
+      process.exit(2);
+      return;
+    }
+    const reason = typeof args["reason"] === "string" && args["reason"].length > 0 ? args["reason"] : "manual";
+    await dispatchFromCli(
+      "mutate",
+      "worktree",
+      "destroy",
+      {
+        taskId: rawTaskId,
+        force: args["force"] === true,
+        deleteBranch: args["keep-branch"] !== true,
+        reason
+      },
+      { command: "worktree-destroy", operation: "worktree.destroy" }
+    );
+  }
+});
+var forceUnlockCommand = defineCommand({
+  meta: {
+    name: "force-unlock",
+    description: "Clear wedged lock state (.git/index.lock + git worktree unlock) for a task."
+  },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "The task ID whose worktree should be force-unlocked (e.g. T9547).",
+      required: true
+    }
+  },
+  async run({ args }) {
+    const rawTaskId = typeof args["taskId"] === "string" ? args["taskId"] : "";
+    if (rawTaskId.length === 0) {
+      cliError("Missing required positional: <taskId>.", 2);
+      process.exit(2);
+      return;
+    }
+    await dispatchFromCli(
+      "mutate",
+      "worktree",
+      "forceUnlock",
+      { taskId: rawTaskId },
+      { command: "worktree-force-unlock", operation: "worktree.forceUnlock" }
+    );
+  }
+});
+var VALID_ADOPT_SOURCES = ["claude-agent", "manual", "adopted"];
+var adoptCommand = defineCommand({
+  meta: {
+    name: "adopt",
+    description: "Register an externally-created worktree (e.g. Claude Code Agent isolation:worktree) in the CLEO SSoT so it surfaces in `cleo worktree list`."
+  },
+  args: {
+    path: {
+      type: "positional",
+      description: "Absolute or relative path to the worktree directory to adopt. For Claude Code Agent worktrees this is typically `.claude/worktrees/<sessionId>/`.",
+      required: true
+    },
+    source: {
+      type: "string",
+      description: `Source classification for this worktree (${VALID_ADOPT_SOURCES.join("|")}). Defaults to \`claude-agent\` for paths under \`.claude/worktrees/\`, else \`manual\`.`
+    },
+    "task-id": {
+      type: "string",
+      description: "Optional task ID to associate with this worktree. When omitted the command attempts to extract it from the branch name."
+    },
+    actor: {
+      type: "string",
+      description: "Override actor name written to the audit log."
+    },
+    recover: {
+      type: "boolean",
+      description: "After adopting, recover a partial ETIMEDOUT worktree by running pnpm install and clearing stale git locks.",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const rawPath = typeof args["path"] === "string" ? args["path"] : "";
+    if (rawPath.length === 0) {
+      cliError("Missing required positional: <path>.", 2);
+      process.exit(2);
+      return;
+    }
+    const rawSource = typeof args["source"] === "string" ? args["source"] : void 0;
+    const source = rawSource !== void 0 && VALID_ADOPT_SOURCES.includes(rawSource) ? rawSource : void 0;
+    const rawTaskId = typeof args["task-id"] === "string" ? args["task-id"] : void 0;
+    const rawActor = typeof args["actor"] === "string" ? args["actor"] : void 0;
+    await dispatchFromCli(
+      "mutate",
+      "worktree",
+      "adopt",
+      {
+        worktreePath: rawPath,
+        ...source !== void 0 ? { source } : {},
+        ...rawTaskId !== void 0 ? { taskId: rawTaskId } : {},
+        ...rawActor !== void 0 ? { actor: rawActor } : {},
+        recover: args["recover"] === true
+      },
+      { command: "worktree-adopt", operation: "worktree.adopt" }
+    );
+  }
+});
+var worktreeCommand = defineCommand({
+  meta: {
+    name: "worktree",
+    description: "Inspect and manage CLEO-attached git worktrees. See `cleo worktree <subcommand> --help` for details."
+  },
+  subCommands: {
+    list: listCommand,
+    adopt: adoptCommand,
+    prune: pruneCommand,
+    destroy: destroyCommand,
+    "force-unlock": forceUnlockCommand
+  },
+  // Early-return when a subcommand was matched; citty still invokes the
+  // parent run() after the subcommand finishes which would otherwise
+  // append the help text to the subcommand's JSON envelope output
+  // (T9686-A bug A4).
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  worktreeCommand
+};
+//# sourceMappingURL=worktree-6RXAJIST.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cleocode/cleo",
-  "version": "2026.10.2",
+  "version": "2026.10.4",
   "description": "CLEO CLI — the assembled product consuming @cleocode/core",
   "type": "module",
   "main": "./dist/cli/index.js",
@@ -31,17 +31,17 @@
     "tree-sitter-rust": "0.23.1",
     "tree-sitter-typescript": "^0.23.2",
     "yaml": "^2.8.3",
-    "@cleocode/animations": "2026.10.2",
-    "@cleocode/contracts": "2026.10.2",
-    "@cleocode/caamp": "2026.10.2",
-    "@cleocode/core": "2026.10.2",
-    "@cleocode/cant": "2026.10.2",
-    "@cleocode/lafs": "2026.10.2",
-    "@cleocode/nexus": "2026.10.2",
-    "@cleocode/paths": "2026.10.2",
-    "@cleocode/playbooks": "2026.10.2",
-    "@cleocode/runtime": "2026.10.2",
-    "@cleocode/worktree": "2026.10.2"
+    "@cleocode/animations": "2026.10.4",
+    "@cleocode/caamp": "2026.10.4",
+    "@cleocode/cant": "2026.10.4",
+    "@cleocode/contracts": "2026.10.4",
+    "@cleocode/core": "2026.10.4",
+    "@cleocode/lafs": "2026.10.4",
+    "@cleocode/paths": "2026.10.4",
+    "@cleocode/playbooks": "2026.10.4",
+    "@cleocode/nexus": "2026.10.4",
+    "@cleocode/runtime": "2026.10.4",
+    "@cleocode/worktree": "2026.10.4"
   },
   "engines": {
     "node": ">=24.16.0"
@@ -63,7 +63,7 @@
   "devDependencies": {
     "@types/node-cron": "^3.0.11",
     "vitest": "^4.1.4",
-    "@cleocode/utils": "2026.10.2"
+    "@cleocode/utils": "2026.10.4"
   },
   "repository": {
     "type": "git",

package/studio-dist/client/_app/immutable/chunks/{Buaay_Q8.js → Btgeq_wq.js}

@@ -1 +1 @@
-import"./DGftG5oL.js";import{o as e}from"./CLP4JZvZ.js";var t=()=>{let t=e;return{page:{subscribe:t.page.subscribe},navigating:{subscribe:t.navigating.subscribe},updated:t.updated}},n={subscribe(e){return t().page.subscribe(e)}};export{n as t};
+import"./DGftG5oL.js";import{o as e}from"./DgEKqO6r.js";var t=()=>{let t=e;return{page:{subscribe:t.page.subscribe},navigating:{subscribe:t.navigating.subscribe},updated:t.updated}},n={subscribe(e){return t().page.subscribe(e)}};export{n as t};

package/studio-dist/client/_app/immutable/chunks/{BJp57kf2.js → CgBjxmu6.js}

@@ -1 +1 @@
-import"./DGftG5oL.js";import{c as e,o as t,s as n}from"./CLP4JZvZ.js";var r={get data(){return e.data},get error(){return e.error},get form(){return e.form},get params(){return e.params},get route(){return e.route},get state(){return e.state},get status(){return e.status},get url(){return e.url}};Object.defineProperty({get from(){return n.current?n.current.from:null},get to(){return n.current?n.current.to:null},get type(){return n.current?n.current.type:null},get willUnload(){return n.current?n.current.willUnload:null},get delta(){return n.current?n.current.delta:null},get complete(){return n.current?n.current.complete:null}},`current`,{get(){throw Error(`Replace navigating.current.<prop> with navigating.<prop>`)}}),t.updated.check;var i=r;export{i as t};
+import"./DGftG5oL.js";import{c as e,o as t,s as n}from"./DgEKqO6r.js";var r={get data(){return e.data},get error(){return e.error},get form(){return e.form},get params(){return e.params},get route(){return e.route},get state(){return e.state},get status(){return e.status},get url(){return e.url}};Object.defineProperty({get from(){return n.current?n.current.from:null},get to(){return n.current?n.current.to:null},get type(){return n.current?n.current.type:null},get willUnload(){return n.current?n.current.willUnload:null},get delta(){return n.current?n.current.delta:null},get complete(){return n.current?n.current.complete:null}},`current`,{get(){throw Error(`Replace navigating.current.<prop> with navigating.<prop>`)}}),t.updated.check;var i=r;export{i as t};