@north-light/crouter 0.3.263 → 0.3.270

package/dist/index.d.ts

@@ -5,6 +5,7 @@ export type { CloseNodeResult } from './core/runtime/close.js';
 export { appendInbox } from './core/feed/inbox.js';
 export type { InboxEntry, InboxTier, InboxKind } from './core/feed/inbox.js';
 export { appendSituationalContext } from './core/runtime/situational-context.js';
+export { isTurnInternal } from './core/runtime/turn-visibility.js';
 export { getNode, listNodes } from './core/canvas/canvas.js';
 export { nodeDir } from './core/canvas/paths.js';
 export type { NodeMeta, NodeRow, NodeStatus, Lifecycle, Mode, } from './core/canvas/types.js';

package/dist/index.js

@@ -21,6 +21,9 @@ export { appendInbox } from './core/feed/inbox.js';
 // upsert-only, narrow surface so an external composer (e.g. Hearth) never needs to
 // learn the storage file itself.
 export { appendSituationalContext } from './core/runtime/situational-context.js';
+// In-process extensions use crouter's admitted turn classification rather than
+// attempting to reconstruct origin and route state independently.
+export { isTurnInternal } from './core/runtime/turn-visibility.js';
 // ── Canvas reads ─────────────────────────────────────────────────────────
 export { getNode, listNodes } from './core/canvas/canvas.js';
 export { nodeDir } from './core/canvas/paths.js';

package/dist/pi-extensions/canvas-inbox-watcher.js

@@ -17,6 +17,7 @@
 import { envNodeId, envProfileId, envWatcherDebounceMs, envWatcherTickMs } from '../shared/env.js';
 import { coalesceBrokerInbox, entryCards, readBrokerCanceledEntryIds, readBrokerCursor, readBrokerInboxSince, reportRefNodeId, } from '../core/runtime/broker/inbox.js';
 import { advanceBrokerInboxCursor, brokerExtensionState } from '../core/runtime/broker/daemon-ops.js';
+import { announceMessageOrigin } from '../core/runtime/stamp/channel.js';
 import { captureGoalIfAbsent, generateAndCommitInitialName } from './broker-local.js';
 import { emitEvent } from '../core/events/emit.js';
 import { errorClassFromError } from '../core/events/errors.js';
@@ -97,6 +98,26 @@ function emitStoredBestEffort(operationId, input) {
         // Delivery state remains authoritative when its observational record cannot append.
     }
 }
+/** The authorship stamped onto a delivered message. A person's words arrive
+ *  verbatim and are stamped as theirs — no channel, because the durable inbox
+ *  is not a transport a reader can attribute. Every other delivery is the
+ *  runtime's inbox card, carrying each entry's attribution as the coalescer
+ *  received it. */
+function deliveryOrigin(delivery) {
+    if (delivery.kind === 'human')
+        return { type: 'human' };
+    return {
+        type: 'runtime',
+        kind: 'inbox',
+        entries: delivery.entries.map((entry) => ({
+            ...(entry.from === null ? {} : { from: entry.from }),
+            ...(entry.from_name === undefined ? {} : { fromName: entry.from_name }),
+            kind: entry.kind,
+            tier: entry.tier,
+            ...(entry.ref === undefined ? {} : { ref: entry.ref }),
+        })),
+    };
+}
 function deliveryFacts(entries, channel) {
     if (entries.length === 0)
         throw new Error(`cannot create an empty ${channel} delivery`);
@@ -729,7 +750,7 @@ class CanvasInboxWatcher {
      *  unit: a throw anywhere requeues the whole entry, so a retry may repeat a
      *  card already handed off (context is restatable; the human's body is not,
      *  and it is sent last). */
-    sendVisible(entries, cards, content, route, stage) {
+    sendVisible(entries, cards, content, origin, route, stage) {
         return this.sendDelivery('visible', entries, () => {
             if (route !== 'idle' && route !== 'steer' && route !== 'followUp') {
                 throw new Error(`visible send requested for non-send route ${route}`);
@@ -737,6 +758,10 @@ class CanvasInboxWatcher {
             for (const card of cards) {
                 this.pi.sendMessage({ customType: SITUATIONAL_CONTEXT_CUSTOM_TYPE, content: card, display: true }, route === 'idle' ? {} : { deliverAs: route });
             }
+            // Claimed by the stamp writer against the message pi persists, so a send
+            // that throws here leaves an announcement nobody claims rather than one
+            // that mislabels a later message.
+            announceMessageOrigin(content, origin);
             if (route === 'idle') {
                 const start = brokerIdleTurnStart();
                 if (start === undefined)
@@ -803,7 +828,7 @@ class CanvasInboxWatcher {
         if (!this.canMutate())
             return { inactive: true, requeueEntryIds };
         if (delivery !== undefined) {
-            const result = this.sendVisible(delivery.entries, delivery.cards, delivery.text, route, stage);
+            const result = this.sendVisible(delivery.entries, delivery.cards, delivery.text, deliveryOrigin(delivery), route, stage);
             if (result === 'inactive')
                 return { inactive: true, requeueEntryIds };
             if (result === 'failed') {

package/dist/pi-extensions/canvas-recap.js

@@ -41,6 +41,7 @@
 import { envNodeId, envRecapIdleMs } from '../shared/env.js';
 import { brokerExtensionState } from '../core/runtime/broker/daemon-ops.js';
 import { generateRecap } from '../core/runtime/recap.js';
+import { writeNodeRecap } from '../core/canvas/node-recap.js';
 import { isReviewBoundary } from '../core/runtime/session-visibility.js';
 import { editorLabelForBrokerNode } from '../core/runtime/broker-extension-render.js';
 import { generateAndCommitRecapName, readRoadmap } from './broker-local.js';
@@ -315,6 +316,9 @@ export function registerCanvasRecap(pi, recapGenerator = generateRecap, nameRege
             // Automatic work paints only while its idle snapshot remains current.
             if ((!manual && activityVersion !== snapshotVersion) || !canPaint())
                 return;
+            // Persist what we are about to paint. The widget dies with the broker; the
+            // file is what `crtr canvas browse` shows for a dormant node.
+            writeNodeRecap(nodeId, briefing);
             recapShown = true;
             recapStale = activityVersion !== snapshotVersion;
             showRecap(briefing);

package/dist/pi-extensions/canvas-stamp.d.ts

@@ -0,0 +1,14 @@
+interface StampCtxLike {
+    sessionManager: {
+        /** Whole file, not the active branch: a session stamp on an abandoned
+         *  branch still describes this file's owner. */
+        getEntries: () => unknown[];
+    };
+}
+interface PiLike {
+    on: (event: 'session_start' | 'message_end', handler: (event: unknown, ctx: StampCtxLike) => void | Promise<void>) => void;
+    appendEntry: (customType: string, data?: unknown) => void;
+}
+/** Register the stamp writer. */
+export declare function registerCanvasStamp(pi: PiLike): void;
+export default registerCanvasStamp;

package/dist/pi-extensions/canvas-stamp.js

@@ -0,0 +1,77 @@
+// canvas-stamp.ts — the sole writer of `crtr-stamp` entries.
+//
+// Two records land in the session jsonl. A SESSION stamp names the node and the
+// crtr release that own the file, appended at session start only when the
+// latest one on disk disagrees — which covers a fresh session, a fork (whose
+// copied history still carries the source node's stamp), a new cycle, and a
+// runtime upgrade mid-node, without a rule per case. A MESSAGE stamp records
+// where one user message came from, joined to it by the message's own
+// timestamp.
+//
+// Every user message is stamped; an origin appears only when a delivery seam
+// announced one (absence means unknown, never a guess). An assistant message is
+// stamped only when an `ext` contribution is pending, so an ordinary turn costs
+// no line.
+//
+// Ordering note: pi runs message_end handlers BEFORE it persists the finalized
+// message, so the stamp is written as that message's structural parent. The
+// join is by `msgTs`, so tree position carries no meaning here.
+import { envNodeId } from '../shared/env.js';
+import { crtrVersion } from '../shared/crtr-version.js';
+import { claimMessageAnnouncement, drainStampExt, hasPendingStampExt, } from '../core/runtime/stamp/channel.js';
+import { CRTR_STAMP_CUSTOM_TYPE, latestSessionStamp, STAMP_SCHEMA_VERSION, } from '../core/runtime/stamp/protocol.js';
+/** Plain text of a message's content (string or content blocks). */
+function messageText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .filter((block) => typeof block === 'object' && block !== null && typeof block.text === 'string')
+            .map((block) => block.text)
+            .join('\n');
+    }
+    return '';
+}
+function envelope(kind, payload) {
+    const ext = drainStampExt();
+    return {
+        v: STAMP_SCHEMA_VERSION,
+        kind,
+        payload,
+        ...(ext === undefined ? {} : { ext }),
+    };
+}
+/** Register the stamp writer. */
+export function registerCanvasStamp(pi) {
+    pi.on('session_start', (_event, ctx) => {
+        const node = envNodeId();
+        if (node === undefined || node.trim() === '')
+            return;
+        const crtr = crtrVersion();
+        const latest = latestSessionStamp(ctx.sessionManager.getEntries());
+        if (latest !== null && latest.payload.node === node && latest.payload.crtr === crtr)
+            return;
+        pi.appendEntry(CRTR_STAMP_CUSTOM_TYPE, envelope('session', { node, crtr }));
+    });
+    pi.on('message_end', (event) => {
+        const message = event?.message;
+        if (message === undefined || message === null)
+            return;
+        if (typeof message.timestamp !== 'number')
+            return;
+        const msgTs = message.timestamp;
+        if (message.role === 'user') {
+            const announcement = claimMessageAnnouncement(messageText(message.content));
+            pi.appendEntry(CRTR_STAMP_CUSTOM_TYPE, envelope('message', {
+                msgTs,
+                ...(announcement === null ? {} : announcement),
+            }));
+            return;
+        }
+        // Any other message earns a line only for a pending contribution.
+        if (!hasPendingStampExt())
+            return;
+        pi.appendEntry(CRTR_STAMP_CUSTOM_TYPE, envelope('message', { msgTs }));
+    });
+}
+export default registerCanvasStamp;

package/dist/pi-extensions/canvas-stophook.js

@@ -33,6 +33,7 @@ import { activeBackgroundBashJobs } from '../core/bash-jobs.js';
 import { CONTEXT_NUDGE_CUSTOM_TYPE, formatCard } from '../shared/generated-context.js';
 import { isReviewBoundary } from '../core/runtime/session-visibility.js';
 import { runRefreshAbort } from '../core/runtime/broker/extension-abort.js';
+import { announceMessageOrigin } from '../core/runtime/stamp/channel.js';
 /** Condense a tool call into one short line for the activity cue. Picks the most
  *  identifying arg (command / path / pattern / description), collapses whitespace,
  *  and hard-caps the length so a giant bash command can't bloat telemetry.json. */
@@ -271,6 +272,7 @@ export function registerCanvasStophook(pi) {
     };
     const enactSettleDirective = (directive, ctx) => {
         if (directive.action === 'reprompt') {
+            announceMessageOrigin(directive.prompt, { type: 'runtime', kind: 'stop-guard' });
             pi.sendUserMessage(directive.prompt, { deliverAs: 'followUp' });
             return;
         }
@@ -566,6 +568,7 @@ export function registerCanvasStophook(pi) {
                 firedBands.add(at);
                 const note = formatCard('context-nudge', {}, steerNote(at, node.lifecycle, node.mode));
                 if (runContinues) {
+                    announceMessageOrigin(note, { type: 'runtime', kind: 'context-nudge' });
                     pi.sendUserMessage(note, { deliverAs: 'steer' });
                 }
                 else {

package/dist/shared/__tests__/env-boundary.test.js

@@ -17,6 +17,7 @@ const MIGRATED_VARS = [
     'CRTR_PROFILE_ID',
     'CRTR_NODE_CWD',
     'CRTR_MODEL_INTENT',
+    'CRTR_MODEL_EXACT',
     'CRTR_HOME',
     'CRTR_STREAM_WATCHDOG_MS',
     'CRTR_WATCHER_TICK_MS',
@@ -35,6 +36,7 @@ const MIGRATED_VARS = [
     'CRTR_WARN_LIVE_BROKERS',
     'CRTR_TEST_UNATTENDED_PARK_MS',
     'CRTR_TEST_PARK_SUMMARY_GRACE_MS',
+    'CRTR_UNATTENDED_PARK_MS',
 ];
 // Matches `process.env['VAR']`, `process.env.VAR`, or `process.env[\`VAR\`]`
 // for exactly one of MIGRATED_VARS — not a longer name that merely starts
@@ -53,8 +55,8 @@ const EXEMPTIONS = new Map([
     ],
     [
         'core/runtime/broker.ts',
-        "clears CRTR_MODEL_INTENT via `delete process.env[...]` — a mutation, " +
-            'not a read, so it stays here per shared/env.ts\'s header comment.',
+        "clears CRTR_MODEL_INTENT and sets CRTR_MODEL_EXACT via process.env — mutations, " +
+            'not reads, so they stay here per shared/env.ts\'s header comment.',
     ],
 ]);
 function tsFilesUnder(dir) {

package/dist/shared/crtr-version.d.ts

@@ -0,0 +1,2 @@
+/** The running crouter package version (`package.json` `version`). */
+export declare function crtrVersion(): string;

package/dist/shared/crtr-version.js

@@ -0,0 +1,18 @@
+// The installed crtr release string, read once per process from the package
+// manifest. Callers that record a version into durable state (the session
+// stamp) and callers that compare against npm (self-update) read this one
+// implementation.
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+let cached = null;
+/** The running crouter package version (`package.json` `version`). */
+export function crtrVersion() {
+    if (cached !== null)
+        return cached;
+    // src|dist/shared/crtr-version.ts → up to src|dist/ → up to pkg root
+    const root = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
+    const parsed = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'));
+    cached = parsed.version;
+    return cached;
+}

package/dist/shared/env.d.ts

@@ -8,6 +8,8 @@ export declare function envNodeCwd(): string | undefined;
  *  undefined. Cleared (not read) via `delete process.env['CRTR_MODEL_INTENT']`
  *  in `runtime/broker.ts` — a mutation, not a read, so it stays there. */
 export declare function envModelIntent(): string | undefined;
+/** Whether the launch recipe requires this broker to keep its exact provider/model. */
+export declare function envModelExact(): boolean;
 /** The raw `CRTR_HOME` override, unresolved. Use `crtrHome()`
  *  (`core/canvas/paths.ts`) to get the resolved canvas-home path; use this
  *  only when a caller needs the override itself — to check whether one is
@@ -67,6 +69,14 @@ export declare function envWarnLiveBrokers(): number | undefined;
 /** Test-only unattended-park interval override (`CRTR_TEST_UNATTENDED_PARK_MS`),
  *  gated by `envNoDaemonAutostart()` at the call site; no production default. */
 export declare function envTestUnattendedParkMs(): number | undefined;
+/** Production unattended-park interval override (`CRTR_UNATTENDED_PARK_MS`), in
+ *  milliseconds; wins over the user-scope config value
+ *  (`readConfig('user').lifecycle.unattendedParkMs`, itself defaulting to 15
+ *  min) whenever set, autostart or not. Unlike `CRTR_TEST_UNATTENDED_PARK_MS`
+ *  this is not gated on `envNoDaemonAutostart()`: it is the env escape hatch
+ *  above the configured knob a deployment sets to tune how long an eligible
+ *  resident idles before its parking turn. */
+export declare function envUnattendedParkMs(): number | undefined;
 /** Test-only park-summary grace-period override
  *  (`CRTR_TEST_PARK_SUMMARY_GRACE_MS`); no production default. */
 export declare function envTestParkSummaryGraceMs(): number | undefined;

package/dist/shared/env.js

@@ -40,6 +40,10 @@ export function envNodeCwd() {
 export function envModelIntent() {
     return process.env['CRTR_MODEL_INTENT'];
 }
+/** Whether the launch recipe requires this broker to keep its exact provider/model. */
+export function envModelExact() {
+    return process.env['CRTR_MODEL_EXACT'] === '1';
+}
 /** The raw `CRTR_HOME` override, unresolved. Use `crtrHome()`
  *  (`core/canvas/paths.ts`) to get the resolved canvas-home path; use this
  *  only when a caller needs the override itself — to check whether one is
@@ -140,10 +144,11 @@ export function envDebug() {
     return process.env['CRTR_DEBUG'] === '1';
 }
 // Precedence — broker-supervision.ts's threshold/interval overrides. Each
-// returns the raw parsed value with NO default: the caller (config for the
-// thresholds, a hardcoded production constant for the intervals) supplies
-// the default, and env wins over it when set. Undefined, unparseable, or
-// non-positive all mean "no override" — the caller's own default applies.
+// returns the raw parsed value with NO default: the caller supplies the
+// default (user config for the broker thresholds and the unattended-park
+// interval, a hardcoded constant for the test-only park-summary grace), and
+// env wins over it when set. Undefined, unparseable, or non-positive all mean
+// "no override" — the caller's own default applies.
 function parsePositiveInteger(raw) {
     if (raw === undefined || raw === '')
         return undefined;
@@ -171,6 +176,16 @@ function parsePositiveMsNoDefault(raw) {
 export function envTestUnattendedParkMs() {
     return parsePositiveMsNoDefault(process.env['CRTR_TEST_UNATTENDED_PARK_MS']);
 }
+/** Production unattended-park interval override (`CRTR_UNATTENDED_PARK_MS`), in
+ *  milliseconds; wins over the user-scope config value
+ *  (`readConfig('user').lifecycle.unattendedParkMs`, itself defaulting to 15
+ *  min) whenever set, autostart or not. Unlike `CRTR_TEST_UNATTENDED_PARK_MS`
+ *  this is not gated on `envNoDaemonAutostart()`: it is the env escape hatch
+ *  above the configured knob a deployment sets to tune how long an eligible
+ *  resident idles before its parking turn. */
+export function envUnattendedParkMs() {
+    return parsePositiveMsNoDefault(process.env['CRTR_UNATTENDED_PARK_MS']);
+}
 /** Test-only park-summary grace-period override
  *  (`CRTR_TEST_PARK_SUMMARY_GRACE_MS`); no production default. */
 export function envTestParkSummaryGraceMs() {

package/dist/shared/generated-context.d.ts

@@ -11,8 +11,7 @@ export declare const STALL_REPROMPT: string;
 /** The daemon's parking mandate: the last turn of a conversation the unattended
  *  clock is concluding. Delivered live, wrapped in a `park` runtime card. It
  *  governs both the node's durable inheritance and reader-facing output:
- *  one update for subscribers and history, then a silent stop with no assistant
- *  prose for an external channel to relay.
+ *  one update for subscribers and history, then a brief completion reply.
  *
  *  The durable inheritance shares a CONTRACT with `node yield`'s pre-invocation
  *  guide (roadmap current, short and shrinking; context dir for in-progress

package/dist/shared/generated-context.js

@@ -16,8 +16,7 @@ export const STALL_REPROMPT = "You've stopped but you're not waiting on anyone a
 /** The daemon's parking mandate: the last turn of a conversation the unattended
  *  clock is concluding. Delivered live, wrapped in a `park` runtime card. It
  *  governs both the node's durable inheritance and reader-facing output:
- *  one update for subscribers and history, then a silent stop with no assistant
- *  prose for an external channel to relay.
+ *  one update for subscribers and history, then a brief completion reply.
  *
  *  The durable inheritance shares a CONTRACT with `node yield`'s pre-invocation
  *  guide (roadmap current, short and shrinking; context dir for in-progress
@@ -28,8 +27,8 @@ export const PARK_SUMMARY_PROMPT = 'This conversation has been idle with nothing
     + '2. Rewrite `$CRTR_CONTEXT_DIR/roadmap.md` for a fresh context window. This is the only handoff document a later fresh cycle receives in full. Preserve the current goal and exit criteria when they still apply, then state the present outcome; what remains or is blocked; decisions or questions still open; exact recovery handles for in-flight state; and the first safe move on return. Keep strategy and present state, not a transcript recap. Delete stale and completed steps instead of marking them done; the roadmap should stay short and shrink. Write a minimal one now if none exists.\n\n'
     + '3. Put supporting material in your context directory only when the roadmap would become bulky without it. Rewrite existing living documents rather than leave superseded versions. Name every supporting file the next cycle must read from the roadmap and say what it is for—the revive shows filenames but does not inject their contents. Task state, identifiers, and recovery detail belong here, not in memory.\n\n'
     + '4. Use memory only for a non-obvious, reusable lesson that should survive this task and is not already recorded. Read `crtr memory write -h`, find before writing, and choose the narrowest scope that will reach the next agent who needs it. Do not put a conversation recap, task status, recovery handles, or facts already captured in code or docs into memory.\n\n'
-    + '5. Push exactly one regular update with `crtr push update --tier deferred`, never `crtr push final`. Write it for subscribers and history, not as a second roadmap. Its first line must stand alone as the current outcome, blocker, or decision that matters; then include only unfinished work, a needed decision, and concrete handles a subscriber may need. This concludes the conversation; it does not finish the mandate.\n\n'
-    + '6. Keep this entire turn silent in the conversation: produce no assistant prose before, between, or after tool calls, and do not narrate the work. Once every required tool call has finished, end the response immediately without emitting any text, sign-off, summary, acknowledgement, or other visible content by emitting the `stop` token with no text. The deferred update from step 5 is the only reader-facing conclusion. A later message reopens you on a fresh context window grounded in your goal and roadmap, so the inheritance you leave now is what you get back.';
+    + '5. Push exactly one regular update with `crtr push update --tier deferred`, never `crtr push final`. Write for someone who has not seen this conversation: name the work in plain terms, say where it stands, and say what remains or is blocked. Put the current outcome in the first line; include only needed decisions and recovery handles. This concludes the conversation, not the mandate.\n\n'
+    + '6. When finished, reply with exactly `done`.';
 /** Static recovery prompts shared by the broker producer and display classifier. */
 export const AUTH_FAULT_RECOVERY_BODY = 'Provider credentials were just updated (a new login landed). Your previous turn stopped on a provider authentication failure. Continue from where you left off and retry the work that failed.';
 export const CONNECTION_FAULT_RECOVERY_BODY = 'The network connection is back online. Your previous turn stopped on a connection error (the network was down). Continue from where you left off and retry the work that failed.';

package/dist/types.d.ts

@@ -157,6 +157,14 @@ export interface BrokerThresholdsConfig {
     /** Defer daemon-initiated revives once the live broker census reaches this count. */
     automaticReviveCap: number;
 }
+/** Host-wide node-lifecycle timing. Read only from user scope by crtrd, like
+ *  `brokerThresholds`: project configuration must not change another user's
+ *  daemon. */
+export interface LifecycleConfig {
+    /** How long an eligible resident idles before its unattended-parking turn
+     *  begins, in milliseconds. `CRTR_UNATTENDED_PARK_MS` overrides this. */
+    unattendedParkMs: number;
+}
 export type KeybindingOverrides = Record<string, string[]>;
 /** Compile-time seam for runtime consumers migrating to semantic binding IDs. */
 export type CanvasAction = {
@@ -251,6 +259,8 @@ export interface ScopeConfig {
      *  Independent attended roots keep their normal viewer behavior. */
     auto_open_child_viewers: boolean;
     brokerThresholds: BrokerThresholdsConfig;
+    /** Host-wide node-lifecycle timing (user scope only). */
+    lifecycle: LifecycleConfig;
     /** Ring a short completion sound in the attach viewer when the node you are
      *  watching finishes a turn and hands control back (the Claude-Code Stop-hook
      *  ding). Only ever fires inside a live viewer pane — a headless/background

package/dist/types.js

@@ -82,6 +82,10 @@ export function defaultScopeConfig() {
         // sized as a backstop that actually engages before the machine does.
         // Override per host with CRTR_MAX_LIVE_BROKERS / CRTR_WARN_LIVE_BROKERS.
         brokerThresholds: { warning: 16, automaticReviveCap: 32 },
+        // The unattended-park idle-eligibility delay: how long an eligible resident
+        // idles before its parking turn begins. Override per host with
+        // CRTR_UNATTENDED_PARK_MS.
+        lifecycle: { unattendedParkMs: 15 * 60_000 },
         completion_bell: true,
         working_gerunds: [...DEFAULT_WORKING_GERUNDS],
         whip_mode: false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.263",
+  "version": "0.3.270",
   "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.263",
+  "version": "0.3.270",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@north-light/crouter",
-      "version": "0.3.263",
+      "version": "0.3.270",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {