@north-light/crouter 0.3.258 → 0.3.259

package/dist/commands/surface/node/cycle.js

@@ -55,7 +55,7 @@ export const surfaceNodeCycleLeaf = defineLeaf({
             { name: 'from', type: 'string', required: false, constraint: 'The node you cycled away from.' },
         ],
         outputKind: 'object',
-        effects: ['Brings the neighbor\'s viewer forefront beside the caller (like `surface node focus`); the viewer you were watching drops to the background.', 'Relaunches the neighbor\'s broker first if it was dormant.'],
+        effects: ['Brings the neighbor\'s viewer forefront beside the caller (like `surface node focus`); the viewer you were watching drops to the background.', 'Opens a parked resident from its saved snapshot without waking it; submitted input wakes it through the normal message path.'],
     },
     run: async (input) => {
         const pane = input['pane'] ?? process.env['TMUX_PANE'] ?? currentTmux()?.pane ?? undefined;
@@ -73,7 +73,7 @@ export const surfaceNodeCycleLeaf = defineLeaf({
         if (target === null)
             return { focused: false, from: fromId };
         // Placement brings the neighbor's viewer forefront beside the caller; the
-        // server (ensureAttach, inside focusViewer) relaunches its broker if dormant.
+        // server keeps an exact parked resident offline until submitted input.
         const res = await focusViewer(targetId, { cwd: target.cwd, name: target.name, pane });
         return { focused: res.focused, node_id: targetId, name: target.name, from: fromId };
     },

package/dist/commands/surface/node/focus.js

@@ -6,11 +6,11 @@ import { cliClient, rethrowAsCliError } from '../../api-client.js';
 import { currentTmux, displayPopup, focusViewer, shellQuote } from './placement.js';
 export const surfaceNodeFocusLeaf = defineLeaf({
     name: 'focus',
-    description: 'bring a node into view without accidentally reviving finished work',
-    whenToUse: 'you want to bring a specific node into view — a live node, or a resident agent that merely stopped, opens (resuming its saved conversation in place) beside your current pane; FINISHED work — a terminal worker, or any node that pushed a final report — opens its saved transcript instead of being put back to work. Use `node lifecycle revive` to deliberately relaunch finished work anyway. Use `surface node cycle` to walk neighbors, and `node message send` to steer without leaving where you are',
+    description: 'bring a node into view without waking parked or finished work',
+    whenToUse: 'you want to bring a specific node into view — a live node opens beside your pane, while a parked resident opens its saved conversation without waking until input is submitted. FINISHED work — a terminal worker, or any node that pushed a final report — opens its saved transcript instead of being put back to work. Use `node lifecycle revive` to deliberately relaunch finished work anyway. Use `surface node cycle` to walk neighbors, and `node message send` to steer without leaving where you are',
     help: {
         name: 'surface node focus',
-        summary: 'bring a node into view — attach to a live broker, resume a resident agent that stopped, or open a saved transcript for finished work without reviving it',
+        summary: 'bring a node into view — attach live, open a parked resident without waking it, or inspect finished work as a saved transcript',
         params: [
             { kind: 'positional', name: 'node', required: true, constraint: 'Node id to focus.' },
             { kind: 'flag', name: 'new-pane', type: 'bool', required: false, constraint: 'Always open a NEW viewer SIDE-BY-SIDE with your current pane instead of moving/reusing the node\'s existing viewer. Two agents on screen at once (F4).' },
@@ -20,11 +20,11 @@ export const surfaceNodeFocusLeaf = defineLeaf({
         output: [
             { name: 'focused', type: 'boolean', required: true, constraint: 'True when the node\'s viewer was brought into view.' },
             { name: 'session', type: 'string', required: false, constraint: 'The tmux session the viewer lives in.' },
-            { name: 'revived', type: 'boolean', required: true, constraint: 'True when focusing had to relaunch the node\'s broker (a live node whose engine was gone, or a stopped resident agent resumed in place); false when its viewer was already attached, and false for a saved-transcript inspection.' },
+            { name: 'revived', type: 'boolean', required: true, constraint: 'True when focusing had to recover a non-parked node\'s broker; false for an already attached viewer, an offline parked resident, or saved-transcript inspection.' },
             { name: 'in_place', type: 'boolean', required: true, constraint: 'True when an existing viewer was navigated to (no new pane); false when a fresh viewer pane was opened or moved beside you.' },
         ],
         outputKind: 'object',
-        effects: ['For active/idle nodes: opens/moves the one surface-attach viewer beside the caller, or navigates to its existing viewer.', 'For a resident node that stopped without finalizing: resumes its saved conversation in place (status returns to active) and opens its viewer — the same path as a live node.', 'For finished work (a terminal node, or any node with a final report): opens a read-only saved transcript popup. It does not launch a broker or change node status.', 'With --new-pane/--in-place on a live node: controls whether the viewer splits beside or replaces the caller pane.'],
+        effects: ['For active/idle nodes: opens/moves the one surface-attach viewer beside the caller, or navigates to its existing viewer.', 'For an unfinalized parked resident: opens the normal conversation viewer from its saved snapshot without launching a broker or changing lifecycle; submitting input sends the durable human message that wakes it.', 'For finished work (a terminal node, or any node with a final report): opens a read-only saved transcript popup. It does not launch a broker or change node status.', 'With --new-pane/--in-place on a conversation viewer: controls whether the viewer splits beside or replaces the caller pane.'],
     },
     run: async (input) => {
         const id = input['node'];
@@ -59,16 +59,16 @@ export const surfaceNodeFocusLeaf = defineLeaf({
         // any node that pushed a final report) is archive: show its persisted
         // transcript, because reviving it would set completed work back in motion, and
         // `node lifecycle revive` remains the explicit way to do that on purpose.
-        // A RESIDENT node with no final report never finished — its `done` is just a
-        // clean broker exit — so it falls through to the live path below, where
-        // ensureAttach's true resume replays the conversation exactly as it stood.
+        // A RESIDENT node with no final report never finished — its parked `done`
+        // falls through to the conversation path, where focus can seat its saved
+        // snapshot without launching an engine.
         if (!isLiveStatus(node.status) && isFinishedWork({ lifecycle: node.lifecycle, finalized: node.final_report != null })) {
             const focused = displayPopup(pane, node.cwd, `crtr node inspect transcript ${shellQuote(id)}`);
             return { focused, session: null, revived: false, in_place: false };
         }
-        // Local viewer tail: open/move the broker-backed viewer beside the caller.
-        // The server (ensureAttach) owns the revive + view.sock wait; pure tmux ops
-        // own the pane placement.
+        // Local viewer tail: open/move the normal conversation viewer beside the
+        // caller. The server owns the serialized live-vs-parked decision; pure tmux
+        // operations own pane placement.
         const res = await focusViewer(id, {
             cwd: node.cwd,
             name: node.name,

package/dist/commands/surface/node/placement.js

@@ -7,6 +7,11 @@ export function viewerEnv() {
     const crtrHome = envHomeOverride();
     return crtrHome !== undefined ? { CRTR_HOME: crtrHome } : {};
 }
+/** Internal startup policy for viewers opened by focus/navigation. Direct
+ * `surface attach` has no marker and keeps its activating default. */
+function focusViewerEnv() {
+    return { ...viewerEnv(), CRTR_ATTACH_WAKE_PARKED: '0' };
+}
 /** The live viewer pane for `nodeId` (the pane a surface-attach viewer tagged
  *  `@crtr_node`), or undefined. Pure tag scan over live panes. */
 export function viewerPaneOf(nodeId) {
@@ -22,7 +27,7 @@ export function viewerPaneOf(nodeId) {
 /** Open a fresh surface-attach viewer SPLIT beside `callerPane` and rebalance
  *  its window to even side-by-side widths. Pure tmux. */
 function openBesideCaller(callerPane, nodeId, cwd, callerSession, revived) {
-    const opened = splitWindow(callerPane, { cwd, env: viewerEnv(), command: `crtr surface attach to ${nodeId}` });
+    const opened = splitWindow(callerPane, { cwd, env: focusViewerEnv(), command: `crtr surface attach to ${nodeId}` });
     if (opened === null)
         return { focused: false, session: null, inPlace: false, revived };
     const loc = paneLocation(opened);
@@ -40,8 +45,12 @@ export async function focusViewer(nodeId, opts) {
     if (callerPane === undefined || callerPane === '') {
         return { focused: false, session: null, inPlace: false, revived: false };
     }
-    // (a) Server ensures the broker engine is alive + its view.sock accepts.
-    const attach = await cliClient().ensureAttach(nodeId).catch(rethrowAsCliError);
+    // (a) Server ensures a live broker is attachable, but leaves an exact parked
+    // resident untouched. This policy is unconditional so an active→parked race
+    // is decided at the daemon's synchronous fleet/launch boundary.
+    const attach = await cliClient()
+        .ensureAttach(nodeId, { resume: true, revive: true, wakeParked: false })
+        .catch(rethrowAsCliError);
     const revived = attach.revived;
     const callerSession = paneLocation(callerPane)?.session ?? null;
     // (b0) --in-place → the caller pane BECOMES this node's viewer, replacing what
@@ -57,8 +66,8 @@ export async function focusViewer(nodeId, opts) {
         catch { /* best-effort */ }
         const window = windowOfPane(callerPane);
         const env = priorNodeId !== undefined && priorNodeId !== ''
-            ? { ...viewerEnv(), CRTR_ATTACH_ROSTER: priorNodeId }
-            : viewerEnv();
+            ? { ...focusViewerEnv(), CRTR_ATTACH_ROSTER: priorNodeId }
+            : focusViewerEnv();
         const ok = respawnPaneSync({ pane: callerPane, cwd: opts.cwd, env, command: `crtr surface attach to ${nodeId}` });
         if (ok && window !== null)
             renameWindow(window, opts.name);

package/dist/core/broker-client/client.d.ts

@@ -22,11 +22,10 @@ export interface BrokerClientOptions {
  *  re-dialing the same target while the node is still alive — a yield
  *  leaves `status='active'` (intent='refresh') and the daemon revives a fresh
  *  broker on the same path. It gives up only when the node is genuinely gone:
- *  a terminal status (done/dead/canceled) or a reaped row (null). `idle` is NOT
- *  terminal — an idle-release node revives on its next inbox wake, so keep
- *  trying (the supervisor waits at a relaxed cadence for as long as the row
- *  stays live). Local canvas rows only — a remote target has no local row, so
- *  callers driving a remote attach must not consult this (see viewer.ts). */
+ *  a terminal status (done/dead/canceled) or a reaped row (null). `idle` and an
+ *  exact unfinalized parked resident are NOT terminal — either can wake while
+ *  the viewer remains seated. Local canvas rows only — a remote target has no
+ *  local row, so callers driving a remote attach must not consult this. */
 export declare function reconnectShouldGiveUp(row: NodeRow | null): boolean;
 /** The plan-fixed interface (Wave 3): `connect()`, `on('frame', …)`,
  *  `send(frame)`, `on('close', …)`, plus `connect`/`error` events. */

package/dist/core/broker-client/client.js

@@ -41,14 +41,18 @@ const REQUEST_TIMEOUT_MS = 10_000;
  *  re-dialing the same target while the node is still alive — a yield
  *  leaves `status='active'` (intent='refresh') and the daemon revives a fresh
  *  broker on the same path. It gives up only when the node is genuinely gone:
- *  a terminal status (done/dead/canceled) or a reaped row (null). `idle` is NOT
- *  terminal — an idle-release node revives on its next inbox wake, so keep
- *  trying (the supervisor waits at a relaxed cadence for as long as the row
- *  stays live). Local canvas rows only — a remote target has no local row, so
- *  callers driving a remote attach must not consult this (see viewer.ts). */
+ *  a terminal status (done/dead/canceled) or a reaped row (null). `idle` and an
+ *  exact unfinalized parked resident are NOT terminal — either can wake while
+ *  the viewer remains seated. Local canvas rows only — a remote target has no
+ *  local row, so callers driving a remote attach must not consult this. */
 export function reconnectShouldGiveUp(row) {
     if (row === null)
         return true;
+    if (row.lifecycle === 'resident'
+        && row.status === 'done'
+        && row.intent === 'parked'
+        && row.final_report == null)
+        return false;
     return row.status === 'done' || row.status === 'dead' || row.status === 'canceled';
 }
 export class BrokerClient extends EventEmitter {

package/dist/core/canvas/browse/model.d.ts

@@ -12,11 +12,11 @@ export declare const SORTS: readonly SortMode[];
 /** Does a node belong to this tab's slice?
  *    All       — every node.
  *    Live      — what you can pick up right now: active | idle, PLUS a resident
- *                agent that stopped without finishing (its broker exited, but
- *                Enter resumes the conversation in place — see `isFinishedWork`).
+ *                agent that stopped without finishing (Enter opens its saved
+ *                conversation; submitted input wakes it — see `isFinishedWork`).
  *                Finished work never appears here.
  *    Dormant   — done | dead | canceled: literally "no engine running". A stopped
- *                resident agent is deliberately on BOTH tabs — it is resumable
+ *                resident agent is deliberately on BOTH tabs — it is openable
  *                (Live) and it is not running (Dormant); both are true and each
  *                tab is the one a different search starts from.
  *    Attention — needs a human: has pending asks OR is parked on a fault.

package/dist/core/canvas/browse/model.js

@@ -11,11 +11,11 @@ export const SORTS = ['tree', 'attention', 'relevance', 'recency'];
 /** Does a node belong to this tab's slice?
  *    All       — every node.
  *    Live      — what you can pick up right now: active | idle, PLUS a resident
- *                agent that stopped without finishing (its broker exited, but
- *                Enter resumes the conversation in place — see `isFinishedWork`).
+ *                agent that stopped without finishing (Enter opens its saved
+ *                conversation; submitted input wakes it — see `isFinishedWork`).
  *                Finished work never appears here.
  *    Dormant   — done | dead | canceled: literally "no engine running". A stopped
- *                resident agent is deliberately on BOTH tabs — it is resumable
+ *                resident agent is deliberately on BOTH tabs — it is openable
  *                (Live) and it is not running (Dormant); both are true and each
  *                tab is the one a different search starts from.
  *    Attention — needs a human: has pending asks OR is parked on a fault.

package/dist/core/canvas/browse/render.js

@@ -435,8 +435,8 @@ const HELP_ROWS = [
     ['Tabs', 'Tab / 1-5', 'All · Live · Dormant · Attention · Pinned'],
     ['Find', '/', 'fuzzy search (name · kind · id · prompts)'],
     ['Pin', 'f', 'star / unstar — floats to top, Pinned tab'],
-    ['Open', '⏎  o', 'resume the node (closes navigator)'],
-    ['', 'O', 'resume, keep browsing (open in background)'],
+    ['Open', '⏎  o', 'open conversation (closes navigator)'],
+    ['', 'O', 'open, keep browsing (background)'],
     ['Act', 'y', 'copy the node id to the clipboard'],
     ['', 'm', 'message the node (no resume)'],
     ['', 'R', 'rename the node'],
@@ -557,7 +557,7 @@ export function renderFrame(state, size, caps = { color: false, color256: false
             ? '⏎ commit  Esc cancel  ⌫ delete'
             : state.readOnly === true
                 ? '↑↓ move  →/← tree  / search  f pin  Tab tabs  ? more  q quit  — read-only remote canvas'
-                : `${hangingHint}↑↓ move  ⏎ resume  O bg  / search  f pin  m msg  x close  R rename  ? more  q quit`;
+                : `${hangingHint}↑↓ move  ⏎ open  O bg  / search  f pin  m msg  x close  R rename  ? more  q quit`;
         lines.push(`${DIM}${clip(footer, width)}${RESET}`);
     }
     // Assemble: home, each line cleared to EOL, then clear below.

package/dist/core/runtime/revive.d.ts

@@ -57,6 +57,18 @@ export interface ReviveResult {
     outcome: ReviveOutcome;
 }
 export type ReviveOutcome = 'launched' | 'already-live' | 'frozen';
+export type AttachReviveDecision = {
+    parked: true;
+} | {
+    parked: false;
+    result: ReviveResult;
+};
+interface ReviveOptions {
+    resume: boolean;
+    capacity: ReviveCapacityPolicy;
+    wakeReason?: ReviveWakeReason;
+    recovery?: boolean;
+}
 /** What a caller wants when the broker cap is full. `freeze` suits a caller
  *  whose reason to run survives waiting (durable mail, a cron sink, a recovery
  *  respawn): the row is marked frozen and the tick relaunches it when a slot
@@ -75,9 +87,10 @@ export type ReviveCapacityPolicy = 'freeze' | 'refuse';
  *  Throws if the node does not exist. All other failures propagate as-is —
  *  callers (daemon, command) decide how to handle.
  */
-export declare function reviveNode(nodeId: string, opts: {
-    resume: boolean;
-    capacity: ReviveCapacityPolicy;
-    wakeReason?: ReviveWakeReason;
-    recovery?: boolean;
-}): ReviveResult;
+export declare function reviveNode(nodeId: string, opts: ReviveOptions): ReviveResult;
+/** The attach-specific entry to the revive boundary. A focus viewer may decline
+ * to wake an exact parked resident while preserving the ordinary activating
+ * attach default. The fleet check and parked decision are synchronous with the
+ * launch below, so an already-running broker wins before dormancy is observed. */
+export declare function decideAttachRevive(nodeId: string, opts: ReviveOptions, wakeParked: boolean): AttachReviveDecision;
+export {};

package/dist/core/runtime/revive.js

@@ -140,6 +140,19 @@ export function hasFreshGroundState(nodeId) {
  *  callers (daemon, command) decide how to handle.
  */
 export function reviveNode(nodeId, opts) {
+    const decision = decideRevive(nodeId, opts, true);
+    if (decision.parked)
+        throw new Error(`reviveNode: internal parked decision for activating revive ${nodeId}`);
+    return decision.result;
+}
+/** The attach-specific entry to the revive boundary. A focus viewer may decline
+ * to wake an exact parked resident while preserving the ordinary activating
+ * attach default. The fleet check and parked decision are synchronous with the
+ * launch below, so an already-running broker wins before dormancy is observed. */
+export function decideAttachRevive(nodeId, opts, wakeParked) {
+    return decideRevive(nodeId, opts, wakeParked);
+}
+function decideRevive(nodeId, opts, wakeParked) {
     let meta = getNode(nodeId);
     if (meta === null) {
         throw new Error(`reviveNode: unknown node ${nodeId}`);
@@ -170,12 +183,21 @@ export function reviveNode(nodeId, opts) {
         // so this is a no-op for a row that is already active.
         transition(nodeId, meta.intent === 'refresh' ? 'refresh-launch' : 'revive');
         return {
-            window: null,
-            session: meta.tmux_session ?? null,
-            resumed: false,
-            outcome: 'already-live',
+            parked: false,
+            result: {
+                window: null,
+                session: meta.tmux_session ?? null,
+                resumed: false,
+                outcome: 'already-live',
+            },
         };
     }
+    // Focus may establish a viewport without establishing an engine. This exact
+    // row has no final latch and no fleet owner; returning before reservation is
+    // what keeps lifecycle, cycle count, pid, inbox cursor, and session untouched.
+    if (!wakeParked && meta.lifecycle === 'resident' && isParked(meta)) {
+        return { parked: true };
+    }
     // The cap, consulted BEFORE any mutation below: a node that cannot get a
     // broker must not have its cycle counter bumped, its session identity
     // cleared, or its bearings drained on the way to being turned away.
@@ -203,14 +225,17 @@ export function reviveNode(nodeId, opts) {
             });
         }
         return {
-            window: null,
-            session: meta.tmux_session ?? null,
-            resumed: false,
-            outcome: 'frozen',
+            parked: false,
+            result: {
+                window: null,
+                session: meta.tmux_session ?? null,
+                resumed: false,
+                outcome: 'frozen',
+            },
         };
     }
     try {
-        return launchRevive(nodeId, meta, opts);
+        return { parked: false, result: launchRevive(nodeId, meta, opts) };
     }
     finally {
         // The slot is either consumed by the fleet registration inside `launch`

package/dist/daemon/api/handlers/attach.js

@@ -6,53 +6,57 @@
 //
 // `{id}` is the target node being attached to.
 import { getNode } from '../../../core/canvas/canvas.js';
-import { reviveNode } from '../../../core/runtime/revive.js';
+import { decideAttachRevive } from '../../../core/runtime/revive.js';
 import { viewSocketPath } from '../../../core/canvas/paths.js';
 import { waitForBrokerViewSocket } from '../../../core/runtime/placement-tmux.js';
 import { notFound, usage } from '../../../core/errors.js';
-/** Validate + narrow the attach-ensure body (both fields optional, default true). */
+/** Validate + narrow the attach-ensure body (all fields optional, default true). */
 function parseAttachBody(body) {
     if (body === undefined || body === null)
-        return { resume: true, revive: true };
+        return { resume: true, revive: true, wakeParked: true };
     if (typeof body !== 'object') {
-        throw usage('attach body must be a JSON object { resume?, revive? }');
+        throw usage('attach body must be a JSON object { resume?, revive?, wakeParked? }');
     }
     const resume = body.resume;
     const revive = body.revive;
+    const wakeParked = body.wakeParked;
     if (resume !== undefined && typeof resume !== 'boolean')
         throw usage('resume must be a boolean');
     if (revive !== undefined && typeof revive !== 'boolean')
         throw usage('revive must be a boolean');
-    return { resume: resume ?? true, revive: revive ?? true };
+    if (wakeParked !== undefined && typeof wakeParked !== 'boolean')
+        throw usage('wakeParked must be a boolean');
+    return { resume: resume ?? true, revive: revive ?? true, wakeParked: wakeParked ?? true };
 }
 async function handleAttach(ctx) {
     const id = ctx.params['id'];
     if (getNode(id) === null)
         throw notFound(`unknown node: ${id}`, { received: id });
-    const { resume, revive } = parseAttachBody(ctx.body);
+    const { resume, revive, wakeParked } = parseAttachBody(ctx.body);
     let revived = false;
     let resumed = false;
+    let parked = false;
     if (revive) {
-        // reviveNode is the ONLY sanctioned broker launcher; a double-revive of a
-        // live node is an idempotent no-op (no `launch` handle) — `revived` reflects
-        // whether a fresh engine actually started.
-        // An attach has a viewer waiting on a socket that only a live broker
-        // publishes, so there is nothing to wait for it with: refuse at the cap and
-        // let the caller see why, rather than freezing and returning a `revived`
-        // that never becomes true.
-        const result = reviveNode(id, { resume, capacity: 'refuse' });
-        revived = result.launch !== undefined;
-        resumed = result.resumed;
-        // If we launched, let the broker publish its view socket so the local
-        // viewer's immediate connect finds it (bounded wait; best-effort).
-        if (revived)
-            await waitForBrokerViewSocket(id);
+        // This decision and reviveNode's fleet guard share one synchronous launch
+        // boundary. Focus may stop at an exact parked resident; ordinary/direct
+        // attach keeps wakeParked=true and preserves attach-implies-revive.
+        const decision = decideAttachRevive(id, { resume, capacity: 'refuse' }, wakeParked);
+        parked = decision.parked;
+        if (!decision.parked) {
+            revived = decision.result.launch !== undefined;
+            resumed = decision.result.resumed;
+            // If we launched, let the broker publish its view socket so the local
+            // viewer's immediate connect finds it (bounded wait; best-effort).
+            if (revived)
+                await waitForBrokerViewSocket(id);
+        }
     }
     const body = {
         node_id: id,
         socket_path: viewSocketPath(id),
         revived,
         resumed,
+        parked,
     };
     return { status: 200, body };
 }

package/dist/daemon/api/handlers/nodes.js

@@ -366,8 +366,15 @@ async function handleSnapshot(ctx) {
         node_id: id,
         snapshot: {
             messages: read.snapshot.messages,
+            ...(read.snapshot.messageIds === undefined ? {} : { messageIds: read.snapshot.messageIds }),
             stats: read.snapshot.stats,
             state: read.snapshot.state,
+            display: read.snapshot.display,
+            ...(read.snapshot.queued === undefined ? {} : { queued: read.snapshot.queued }),
+            ...(read.snapshot.toolGroupSummaries === undefined
+                ? {}
+                : { toolGroupSummaries: read.snapshot.toolGroupSummaries }),
+            ...(read.snapshot.workingActivity === undefined ? {} : { workingActivity: read.snapshot.workingActivity }),
         },
         commands: read.commands.map((c) => ({ name: c.name, description: c.description, source: c.source })),
         captured_at: nowIso(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.258",
+  "version": "0.3.259",
   "description": "crtr — agent runtime with memory, plugins, and marketplaces",
   "type": "module",
   "main": "dist/index.js",

package/runtime.lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.258",
+  "version": "0.3.259",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@north-light/crouter",
-      "version": "0.3.258",
+      "version": "0.3.259",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {