@autono/pinbox-core 0.1.0

package/dist/hub.d.ts

@@ -0,0 +1,125 @@
+import { t as Connector } from "./types-BLNQb7MH.js";
+import { c as PinStore } from "./store-DHbwWu93.js";
+//#region src/hub.d.ts
+type Identity = {
+  userId: string;
+  tenantId?: string;
+  name?: string;
+  email?: string;
+};
+type VerifyFn = (req: Request) => Promise<Identity | null>;
+type HubOptions = {
+  store: PinStore;
+  token: string;
+  enrichEnv?: () => {
+    branch?: string;
+    commit?: string;
+  };
+  verify?: VerifyFn;
+  connectors?: Connector[];
+};
+type RouteModule = (req: Request, url: URL, opts: HubOptions) => Promise<Response | null>;
+type HubErrorCode = "E_INTERNAL" | "E_INVALID_INPUT" | "E_NOT_FOUND" | "E_CONFLICT" | "E_SESSION_GONE" | "E_DELIVERY" | "E_WS_PROTOCOL" | "E_ATTACHMENT" | "E_CONNECTOR" | "E_AUTH";
+declare function createHubHandler(opts: HubOptions): (req: Request) => Promise<Response>;
+declare function match(path: string, pattern: RegExp): string | null;
+declare function mustGetPin(store: PinStore, id: string): {
+  text: string;
+  kind: "move" | "note";
+  target?: {
+    url?: string | undefined;
+    selector?: string | undefined;
+    tag?: string | undefined;
+    rect?: {
+      x: number;
+      y: number;
+      width: number;
+      height: number;
+    } | undefined;
+    fixed?: boolean | undefined;
+    anchor?: string | undefined;
+    source?: {
+      file: string;
+      line?: number | undefined;
+      via: "framework" | "none" | "plugin";
+    } | undefined;
+    context?: {
+      classes?: string[] | undefined;
+      styles?: Record<string, string> | undefined;
+      aria?: Record<string, string> | undefined;
+      nearbyText?: string | undefined;
+      selectedText?: string | undefined;
+    } | undefined;
+  } | undefined;
+  move?: {
+    from: {
+      x: number;
+      y: number;
+      width: number;
+      height: number;
+    };
+    to: {
+      x: number;
+      y: number;
+      width: number;
+      height: number;
+    };
+  } | undefined;
+  env?: {
+    viewport?: {
+      w: number;
+      h: number;
+      dpr: number;
+    } | undefined;
+    browser?: string | undefined;
+    os?: string | undefined;
+    colorScheme?: "dark" | "light" | undefined;
+    branch?: string | undefined;
+    commit?: string | undefined;
+  } | undefined;
+  author: {
+    userId: string;
+    name?: string | undefined;
+    email?: string | undefined;
+  };
+  agentSession?: {
+    agent: string;
+    key: string;
+    cwd?: string | undefined;
+  } | undefined;
+  attachments?: {
+    id: string;
+    kind: "file" | "screenshot";
+    path?: string | undefined;
+    url?: string | undefined;
+    contentType?: string | undefined;
+    width?: number | undefined;
+    height?: number | undefined;
+  }[] | undefined;
+  id: string;
+  schemaVersion: 1;
+  status: "open" | "resolved";
+  createdAt: string;
+  resolution?: {
+    by: "agent" | "human";
+    note?: string | undefined;
+    commit?: string | undefined;
+    at: string;
+  } | undefined;
+  verification?: {
+    outcome: "accepted" | "reopened";
+    at: string;
+  } | undefined;
+  links?: {
+    connector: string;
+    ref: string;
+    url: string;
+  }[] | undefined;
+};
+declare function readJson(req: Request): Promise<unknown>;
+declare class BodyNotJsonError extends Error {}
+declare function ok(status: number, data: unknown): Response;
+declare function err(status: number, code: HubErrorCode, message: string, extra?: {
+  hint?: string;
+}): Response;
+//#endregion
+export { BodyNotJsonError, type HubErrorCode, HubOptions, Identity, RouteModule, VerifyFn, createHubHandler, err, match, mustGetPin, ok, readJson };

package/dist/hub.js

@@ -0,0 +1,2 @@
+import { a as mustGetPin, i as match, n as createHubHandler, o as ok, r as err, s as readJson, t as BodyNotJsonError } from "./hub-QYz6OqYQ.js";
+export { BodyNotJsonError, createHubHandler, err, match, mustGetPin, ok, readJson };

package/dist/markdown.d.ts

@@ -0,0 +1,14 @@
+import { a as Pin } from "./schema-BOTmn5SM.js";
+//#region src/markdown.d.ts
+type DetailLevel = "compact" | "standard" | "forensic";
+declare function pinsToMarkdown(pins: Pin[], level: DetailLevel): string;
+/**
+ * The "where" in the headline, most specific first: a browser pin has a selector, a
+ * terminal `--file` pin has a source anchor, a `--url` pin has a URL. A pin with none
+ * of them is still a valid pin — the headline just drops the locus and its separator.
+ * Exported so every one-line pin summary (delivery/context.ts, the CLI's list) names
+ * a pin the same way.
+ */
+declare function pinLocus(pin: Pin): string | undefined;
+//#endregion
+export { DetailLevel, pinLocus, pinsToMarkdown };

package/dist/markdown.js

@@ -0,0 +1,87 @@
+//#region src/markdown.ts
+function pinsToMarkdown(pins, level) {
+	return pins.map((pin) => pinToMarkdown(pin, level).join("\n")).join("\n");
+}
+function pinToMarkdown(pin, level) {
+	const lines = [headline(pin)];
+	if (level === "compact") return lines;
+	lines.push(...standardFacts(pin));
+	if (level === "standard") return lines;
+	lines.push(...forensicBlock(pin));
+	return lines;
+}
+/** `- [open] <where> — <text> (<id>)`, minus the locus when the pin names no place. */
+function headline(pin) {
+	const where = pinLocus(pin);
+	const head = where === void 0 ? "" : `${where} — `;
+	return `- [${pin.status}] ${head}${pin.text} (${pin.id})`;
+}
+/** The indented context lines, each present only when the fact behind it exists. */
+function standardFacts(pin) {
+	const target = pin.target;
+	const lines = [];
+	if (target?.url !== void 0) lines.push(`  - url: ${target.url}`);
+	const source = sourceRef(pin);
+	if (source !== void 0) lines.push(`  - source: ${source}`);
+	const rect = target?.rect;
+	if (rect) lines.push(`  - rect: ${rect.x},${rect.y} ${rect.width}x${rect.height}`);
+	const nearby = target?.context?.nearbyText;
+	if (nearby !== void 0) lines.push(`  - nearby: "${nearby}"`);
+	return lines;
+}
+/**
+* The fenced JSON record: target.context + env. A terminal pin with no git stamp and
+* no context has nothing to record — it gets no fence, because an empty one is noise
+* the agent still pays tokens for.
+*/
+function forensicBlock(pin) {
+	const forensic = {};
+	if (pin.target?.context) forensic["context"] = pin.target.context;
+	if (pin.env && Object.keys(pin.env).length > 0) forensic["env"] = pin.env;
+	if (Object.keys(forensic).length === 0) return [];
+	return [
+		"",
+		"  ```json",
+		...renderJson(forensic, 0).split("\n").map((line) => `  ${line}`),
+		"  ```"
+	];
+}
+/**
+* The "where" in the headline, most specific first: a browser pin has a selector, a
+* terminal `--file` pin has a source anchor, a `--url` pin has a URL. A pin with none
+* of them is still a valid pin — the headline just drops the locus and its separator.
+* Exported so every one-line pin summary (delivery/context.ts, the CLI's list) names
+* a pin the same way.
+*/
+function pinLocus(pin) {
+	return pin.target?.selector ?? sourceRef(pin) ?? pin.target?.url;
+}
+function sourceRef(pin) {
+	const source = pin.target?.source;
+	if (source === void 0) return void 0;
+	return source.line === void 0 ? source.file : `${source.file}:${source.line}`;
+}
+const INLINE_WIDTH = 80;
+function renderJson(value, indent, cursor = indent) {
+	if (value === null || typeof value !== "object") return JSON.stringify(value);
+	const inline = inlineJson(value);
+	if (cursor + inline.length <= INLINE_WIDTH) return inline;
+	const pad = " ".repeat(indent + 2);
+	if (Array.isArray(value)) return `[\n${value.map((item) => `${pad}${renderJson(item, indent + 2)}`).join(",\n")}\n${" ".repeat(indent)}]`;
+	return `{\n${jsonEntries(value).map(([key, item]) => {
+		const name = JSON.stringify(key);
+		return `${pad}${name}: ${renderJson(item, indent + 2, indent + 2 + name.length + 2)}`;
+	}).join(",\n")}\n${" ".repeat(indent)}}`;
+}
+function inlineJson(value) {
+	if (value === null || typeof value !== "object") return JSON.stringify(value);
+	if (Array.isArray(value)) return `[${value.map(inlineJson).join(", ")}]`;
+	const entries = jsonEntries(value);
+	if (entries.length === 0) return "{}";
+	return `{ ${entries.map(([key, item]) => `${JSON.stringify(key)}: ${inlineJson(item)}`).join(", ")} }`;
+}
+function jsonEntries(value) {
+	return Object.entries(value).filter(([, item]) => item !== void 0);
+}
+//#endregion
+export { pinLocus, pinsToMarkdown };

package/dist/payload-m1DbRWDD.d.ts

@@ -0,0 +1,6 @@
+import { a as Pin } from "./schema-BOTmn5SM.js";
+import "./store-DHbwWu93.js";
+//#region src/delivery/payload.d.ts
+type GetPin = (id: string) => Pin | null;
+//#endregion
+export { GetPin as t };

package/dist/poll-BrcAuaAz.js

@@ -0,0 +1,252 @@
+//#region src/connectors/mirror.ts
+function createConnectorEvents(store, pinId) {
+	return {
+		async onRemoteComment(_link, comment) {
+			store.addThreadMessage(pinId, "mirror", comment.text, { origin: comment.origin });
+		},
+		async onRemoteStatus(_link, status) {
+			const pin = store.getPin(pinId);
+			if (pin === null) return;
+			if (status === "closed") {
+				if (pin.status !== "resolved") store.resolvePin(pinId, "agent");
+				return;
+			}
+			if (pin.status !== "resolved") return;
+			store.verifyPin(pinId, "reopened");
+		}
+	};
+}
+/**
+* The §7 skip rule, tested exhaustively: messages newer than the cursor that did NOT come
+* from this connector. Human/agent messages flow out; mirrors flow out only cross-connector
+* (a slack-origin mirror is outbound for github); origin-less mirrors (local notices) and
+* anything tagged `<connector>:` never echo back.
+*/
+function outboundCandidates(thread, connector, since) {
+	const prefix = `${connector}:`;
+	return thread.filter((message) => {
+		if (since !== null && message.at <= since) return false;
+		if ((message.origin ?? "").startsWith(prefix)) return false;
+		if (message.role === "mirror") return message.origin !== void 0;
+		return true;
+	});
+}
+//#endregion
+//#region src/connectors/inbound.ts
+/** The §7 sinks plus the replay filter and the transition probe the cursor needs. */
+function inboundEvents(store, pinId, connector, statusPushed) {
+	const sinks = createConnectorEvents(store, pinId);
+	const unmatched = mirroredCounts(store.getThread(pinId), connector);
+	let transitionedAt = null;
+	return {
+		events: {
+			async onRemoteComment(link, comment) {
+				const key = mirrorKey(comment.origin, comment.text);
+				const already = unmatched.get(key) ?? 0;
+				if (already > 0) {
+					unmatched.set(key, already - 1);
+					return;
+				}
+				await sinks.onRemoteComment(link, comment);
+			},
+			async onRemoteStatus(link, status) {
+				if (statusPushed) return;
+				const before = store.getPin(pinId)?.status;
+				await sinks.onRemoteStatus(link, status);
+				transitionedAt = transitionStamp(before, store.getPin(pinId)) ?? transitionedAt;
+			}
+		},
+		transitionedAt: () => transitionedAt
+	};
+}
+/** How many times each (origin, text) already sits in the thread as this connector's mirror. */
+function mirroredCounts(thread, connector) {
+	const prefix = `${connector}:`;
+	const counts = /* @__PURE__ */ new Map();
+	for (const message of thread) {
+		const origin = message.origin;
+		if (message.role !== "mirror" || origin === void 0 || !origin.startsWith(prefix)) continue;
+		const key = mirrorKey(origin, message.text);
+		counts.set(key, (counts.get(key) ?? 0) + 1);
+	}
+	return counts;
+}
+/** NUL separator: it cannot occur in an origin tag, so the two fields never blur. */
+function mirrorKey(origin, text) {
+	return `${origin}\u0000${text}`;
+}
+/** The timestamp the sinks stamped a status transition with, or null if none happened. */
+function transitionStamp(before, after) {
+	if (before === void 0 || after === null || after.status === before) return null;
+	return (after.status === "resolved" ? after.resolution?.at : after.verification?.at) ?? (/* @__PURE__ */ new Date()).toISOString();
+}
+//#endregion
+//#region src/connectors/outbound.ts
+/**
+* Everything owed to the remote for this link, oldest first. The status transition is an
+* op like any other precisely so the watermark stays a single ordered cursor: if it were
+* flushed out of band, a watermark past its timestamp would drop it on the next drain.
+* Sort is stable, so a transition stamped in the same millisecond as a comment still goes
+* out after it (comments, then the close).
+*/
+function outboundPlan(thread, connector, pin, since) {
+	const ops = outboundCandidates(thread, connector, since).map((message) => ({
+		at: message.at,
+		kind: "comment",
+		message
+	}));
+	const status = pendingStatus(pin, since);
+	if (status !== null) ops.push({
+		at: status.at,
+		kind: "status",
+		status: status.status
+	});
+	return ops.sort((a, b) => a.at < b.at ? -1 : a.at > b.at ? 1 : 0);
+}
+/** The local status transition newer than the cursor, or null — §7's outbound half (A2). */
+function pendingStatus(pin, since) {
+	const newerThanCursor = (at) => since === null || at > since;
+	const resolution = pin.resolution;
+	if (pin.status === "resolved" && resolution !== void 0 && newerThanCursor(resolution.at)) return {
+		status: "closed",
+		at: resolution.at
+	};
+	const verification = pin.verification;
+	if (pin.status === "open" && verification?.outcome === "reopened" && newerThanCursor(verification.at)) return {
+		status: "open",
+		at: verification.at
+	};
+	return null;
+}
+/** Execute the plan in order, stopping at the first throw. Never rejects — the caller
+* banks the watermark before it re-raises, so progress is never lost to an exception. */
+async function flushOutbound(connector, link, ops) {
+	const posted = /* @__PURE__ */ new Set();
+	let statusPushed = false;
+	let done = 0;
+	for (const op of ops) {
+		try {
+			if (op.kind === "comment") {
+				await connector.postComment(link, op.message);
+				posted.add(op.message.id);
+			} else {
+				await connector.setRemoteStatus(link, op.status);
+				statusPushed = true;
+			}
+		} catch (error) {
+			return {
+				posted,
+				statusPushed,
+				watermark: resumeWatermark(ops, done),
+				error
+			};
+		}
+		done += 1;
+	}
+	return {
+		posted,
+		statusPushed,
+		watermark: ops.at(-1)?.at ?? null,
+		error: null
+	};
+}
+/**
+* How far a partial flush may move the cursor: strictly below the first unfinished op's
+* stamp. Ops sharing a millisecond cannot be split by a timestamp cursor, so a tie group
+* containing unfinished work holds the cursor below the whole group — the landed members
+* are re-sent on the next drain (one duplicate) rather than the unfinished ones being
+* silently dropped. Distinct stamps, the ordinary case, resume exactly.
+*/
+function resumeWatermark(ops, done) {
+	const pending = ops[done]?.at;
+	if (pending === void 0) return ops.at(-1)?.at ?? null;
+	for (let i = done - 1; i >= 0; i -= 1) {
+		const at = ops[i]?.at;
+		if (at !== void 0 && at < pending) return at;
+	}
+	return null;
+}
+//#endregion
+//#region src/connectors/poll.ts
+const POLL_OPEN_MS = 6e4;
+const POLL_RESOLVED_MS = 6e5;
+/** Per-pin failures are caught + logged to stderr; the drain never throws (§6 dispatch discipline). */
+async function drainConnectorPolls(store, connectors, now) {
+	const at = now ?? (/* @__PURE__ */ new Date()).toISOString();
+	for (const pin of store.pinsDueBefore(at)) try {
+		await drainPin(store, connectors, pin, at);
+	} catch (cause) {
+		console.error(`pinbox: connector poll failed for ${pin.id}:`, cause);
+	}
+}
+async function drainPin(store, connectors, pin, at) {
+	let drained = 0;
+	for (const row of store.links.all().filter((r) => r.pinId === pin.id)) {
+		const connector = connectors.find((c) => c.name === row.link.connector);
+		if (connector === void 0) continue;
+		await syncLink(store, connector, pin, row, at);
+		drained += 1;
+	}
+	if (drained === 0) return;
+	rearm(store, pin, at);
+}
+/** One link: drain it, bank however far it got, then re-raise any failure. Banking BEFORE
+* re-raising is the whole point — a partial flush that already reached the remote must
+* never be replayed, or the user sees duplicate comments on their issue. */
+async function syncLink(store, connector, pin, row, at) {
+	const result = await drainLink(store, connector, pin, row.link, row.lastSyncedAt, at);
+	if (advances(result.syncedAt, row.lastSyncedAt)) store.links.markSynced(pin.id, row.link, result.syncedAt);
+	if (result.error !== null) throw result.error;
+}
+/** Re-arm off the post-sync status (an inbound close moves the pin to the slow cadence). */
+function rearm(store, pin, at) {
+	const cadence = (store.getPin(pin.id)?.status ?? pin.status) === "open" ? POLL_OPEN_MS : POLL_RESOLVED_MS;
+	store.setDueAt(pin.id, new Date(Date.parse(at) + cadence).toISOString());
+}
+async function drainLink(store, connector, pin, link, lastSyncedAt, at) {
+	const flush = await flushOutbound(connector, link, outboundPlan(store.getThread(pin.id), connector.name, pin, lastSyncedAt));
+	if (flush.error !== null) return {
+		syncedAt: flush.watermark,
+		error: flush.error
+	};
+	const inbound = inboundEvents(store, pin.id, connector.name, flush.statusPushed);
+	try {
+		await connector.sync(link, inbound.events);
+	} catch (error) {
+		return {
+			syncedAt: flush.watermark,
+			error
+		};
+	}
+	const syncedAt = latest(at, flush.watermark, inbound.transitionedAt()) ?? at;
+	const second = await flushOutbound(connector, link, lateComments(store, connector, pin, lastSyncedAt, syncedAt, flush.posted));
+	if (second.error !== null) return {
+		syncedAt: latest(flush.watermark, second.watermark),
+		error: second.error
+	};
+	return {
+		syncedAt,
+		error: null
+	};
+}
+/** Messages the cursor is about to pass that this drain has not posted yet. */
+function lateComments(store, connector, pin, lastSyncedAt, syncedAt, posted) {
+	return outboundCandidates(store.getThread(pin.id), connector.name, lastSyncedAt).filter((message) => message.at <= syncedAt && !posted.has(message.id)).map((message) => ({
+		at: message.at,
+		kind: "comment",
+		message
+	}));
+}
+/** Newest of the given stamps, ignoring nulls. */
+function latest(...stamps) {
+	let newest = null;
+	for (const stamp of stamps) if (stamp !== null && (newest === null || stamp > newest)) newest = stamp;
+	return newest;
+}
+/** A cursor only ever moves forward — a banked partial watermark must not regress it. */
+function advances(next, current) {
+	if (next === null) return false;
+	return current === null || next > current;
+}
+//#endregion
+export { outboundCandidates as a, createConnectorEvents as i, POLL_RESOLVED_MS as n, drainConnectorPolls as r, POLL_OPEN_MS as t };

package/dist/proc-BMp_pbPS.js

@@ -0,0 +1,42 @@
+import { PinSchema, ThreadMessageSchema } from "./schema.js";
+import { n as buildReplyPrompt, t as buildInjectionContext } from "./context-BHcEpzVb.js";
+//#region src/delivery/payload.ts
+/**
+* Injection context for pin.created; the fenced reply prompt for thread.message.
+* A thread.message payload carries only pinId, but buildReplyPrompt needs the Pin —
+* the serve boot passes (id) => store.getPin(id) as getPin; without it, reply
+* deliveries fail (retryable) rather than ship a pinless payload.
+*/
+function payloadForEvent(event, adapter, getPin) {
+	if (event.type === "pin.created") return buildInjectionContext([PinSchema.parse(event.payload)]);
+	if (event.type === "thread.message") {
+		const message = ThreadMessageSchema.parse(event.payload);
+		const pin = getPin?.(message.pinId) ?? null;
+		if (pin === null) throw new Error(`pin ${message.pinId} not found for ${adapter} payload (adapter needs opts.getPin)`);
+		return buildReplyPrompt(pin, message);
+	}
+	throw new Error(`${adapter} adapter cannot deliver ${event.type}`);
+}
+//#endregion
+//#region src/delivery/proc.ts
+/**
+* Bun.which against the CURRENT process.env.PATH — Bun caches the startup environ for
+* bare-name spawn resolution and default child env, so both are passed explicitly
+* (measured: a runtime PATH prepend was ignored by Bun.which and Bun.spawn alike).
+*/
+function resolveBinary(binary) {
+	return Bun.which(binary, { PATH: process.env["PATH"] ?? "" });
+}
+/**
+* Await close, never exit (deep-dive §1.8b): drain both pipes to EOF, THEN await the
+* exit code — a probe lost 65,538 of 200,000 bytes awaiting exit alone.
+*/
+async function drainToExit(proc) {
+	const [, stderrText] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text()]);
+	return {
+		code: await proc.exited,
+		stderr: stderrText.trim()
+	};
+}
+//#endregion
+export { resolveBinary as n, payloadForEvent as r, drainToExit as t };

package/dist/router-D3dDjIaD.d.ts

@@ -0,0 +1,62 @@
+import { a as Pin, m as ThreadMessage } from "./schema-BOTmn5SM.js";
+import { t as Session } from "./sessions-CJdMBH3C.js";
+import { c as PinStore, l as StoredEvent } from "./store-DHbwWu93.js";
+//#region src/delivery/context.d.ts
+/**
+ * The per-turn injection context: every open pin at the `compact` dial,
+ * between a data-quoting header and a one-line skill pointer.
+ */
+declare function buildInjectionContext(pins: Pin[]): string;
+/** The resume/openclaw payload for one thread reply: the message text fenced as data. */
+declare function buildReplyPrompt(pin: Pin, message: ThreadMessage): string;
+//#endregion
+//#region src/delivery/hooks.d.ts
+/** Agents whose hook systems can register + pull (research §1: shared hooks schema). */
+declare const HOOK_CAPABLE_AGENTS: ReadonlySet<string>;
+declare function createHooksAdapter(): DeliveryAdapter;
+//#endregion
+//#region src/delivery/router.d.ts
+interface DeliveryAdapter {
+  readonly name: string;
+  matches(session: Session): boolean | Promise<boolean>;
+  deliver(event: StoredEvent, session: Session): Promise<void>;
+}
+declare const DEFAULT_HOOKS_ESCALATE_MS = 600000;
+/** Escalation window for pull rows: PINBOX_HOOKS_ESCALATE_MS, default 10 min. */
+declare function hooksEscalateMs(): number;
+declare class DeliveryRouter {
+  private readonly store;
+  private readonly adapters;
+  private chain;
+  constructor(opts: {
+    store: PinStore;
+    adapters: DeliveryAdapter[];
+  });
+  /** THE single entry point; never throws — failures land in the queue. */
+  dispatch(event: StoredEvent): Promise<void>;
+  /**
+   * Runs on hub wake + a coarse unref'd interval: (a) boot/cursor reconciliation,
+   * (b) retry/escalate due pending rows, (c) assign unassigned rows to the active
+   * session. Never rejects.
+   */
+  drainDue(now?: string): Promise<void>;
+  private enqueueWork;
+  private dispatchOne;
+  /**
+   * Deliverable events are pin.created and thread.message with role human|mirror
+   * (rule 3: agent-authored events are never delivered back). Everything else —
+   * pin.resolved, and later event types — is skipped-by-design.
+   */
+  private route;
+  private bindTarget;
+  private attemptNew;
+  private drainNow;
+  private retryRow;
+  private claimRow;
+  private selectAdapter;
+  private rotatedAfter;
+  private recordFailure;
+  private eventOf;
+}
+//#endregion
+export { HOOK_CAPABLE_AGENTS as a, buildReplyPrompt as c, hooksEscalateMs as i, DeliveryAdapter as n, createHooksAdapter as o, DeliveryRouter as r, buildInjectionContext as s, DEFAULT_HOOKS_ESCALATE_MS as t };