@phnx-labs/agents-cli 1.22.112 → 1.22.114

package/dist/lib/session/throughput.d.ts

@@ -8,9 +8,7 @@
  * straight off `agents sessions --active --json` instead (issue #741).
  */
 /** Agents whose transcript formats report per-turn output-token usage. */
-export type ThroughputAgent = 'claude' | 'codex' | 'gemini';
-/** Rolling window (seconds) the throughput average is computed over. */
-export declare const DEFAULT_THROUGHPUT_WINDOW_SEC = 60;
+type ThroughputAgent = 'claude' | 'codex' | 'gemini';
 /**
  * Output-token throughput (tokens/sec) over the last `windowSec` seconds.
  *
@@ -28,3 +26,4 @@ export declare const DEFAULT_THROUGHPUT_WINDOW_SEC = 60;
  *     tokens: {output, thoughts}}]}`. Caller must pass the whole file.
  */
 export declare function computeTokPerSec(sessionContent: string, agent: ThroughputAgent, windowSec?: number, now?: number): number;
+export {};

package/dist/lib/session/throughput.js

@@ -8,7 +8,7 @@
  * straight off `agents sessions --active --json` instead (issue #741).
  */
 /** Rolling window (seconds) the throughput average is computed over. */
-export const DEFAULT_THROUGHPUT_WINDOW_SEC = 60;
+const DEFAULT_THROUGHPUT_WINDOW_SEC = 60;
 /**
  * Output-token throughput (tokens/sec) over the last `windowSec` seconds.
  *

package/dist/lib/session/timeline-pass.d.ts

@@ -19,30 +19,15 @@
  *     picks it up whole.
  */
 import type { ActiveSession } from './active.js';
-import { type SessionTimelineCacheRow, type SessionTimelineEntry } from './db.js';
 import type { SessionAgentId, SessionEvent } from './types.js';
-/** Sessions folded per tick. The tick's own deadline is 30 s; this stays well inside it. */
-export declare const TIMELINE_PASS_MAX_PER_TICK = 8;
 /** Bytes one session may consume in one tick. A bigger backlog catches up over ticks. */
 export declare const TIMELINE_PASS_MAX_BYTES_PER_SESSION: number;
-/**
- * Bytes the whole pass may consume in one tick, across every session.
- *
- * The per-session cap alone is not a bound on the TICK: on a cold cache eight
- * live sessions each fold from offset 0, and eight multi-megabyte transcripts
- * parsed back to back is what blew the 30 s `session-state` deadline and parked
- * the service on this fleet (observed 2026-09-06). A tick budget makes a cold
- * start catch up over a few ticks instead of stalling one.
- */
-export declare const TIMELINE_PASS_MAX_BYTES_PER_TICK: number;
 /**
  * Ceiling on a whole-file re-parse for a harness with no resumable reader.
  * Beyond it the timeline is reported `partial` rather than wedging the tick —
  * the same honesty rule the tool index applies at its own in-memory limit.
  */
 export declare const TIMELINE_PASS_MAX_WHOLE_FILE_BYTES: number;
-/** Events folded from one non-resumable whole-file parse before reporting `partial`. */
-export declare const TIMELINE_PASS_MAX_EVENTS = 20000;
 /**
  * How long a non-resumable harness's timeline may go stale before the pass
  * re-parses its transcript whole.
@@ -56,7 +41,7 @@ export declare const TIMELINE_PASS_MAX_EVENTS = 20000;
  * quarter of the cost.
  */
 export declare const TIMELINE_PASS_NON_RESUMABLE_MIN_INTERVAL_MS = 60000;
-export interface TimelinePassResult {
+interface TimelinePassResult {
     /** Sessions whose timeline was folded and written this tick. */
     computed: number;
     /** Sessions whose cached timeline already matched the transcript bytes. */
@@ -64,7 +49,7 @@ export interface TimelinePassResult {
     /** Sessions skipped: unreadable transcript, no id/file, or no parseable transcript. */
     skipped: number;
 }
-export interface TimelinePassOptions {
+interface TimelinePassOptions {
     /** Live rows to fold. Defaults to the local active-sessions cache. */
     sessions?: ActiveSession[];
     budget?: number;
@@ -88,31 +73,6 @@ export interface TimelinePassOptions {
  * fold two different event streams for the same session.
  */
 export declare function parseTimelineEvents(filePath: string, agent: SessionAgentId): SessionEvent[];
-/** One session's fold: the entry to cache, and what it actually cost to produce. */
-export interface SessionTimelineFold {
-    entry: SessionTimelineEntry;
-    /**
-     * Bytes this fold READ off disk — what the tick's byte budget is debited by.
-     *
-     * Not the transcript's growth delta: a non-resumable harness re-parses the
-     * WHOLE file every time, so eight 3 MiB sessions grown by 10 KB each read
-     * 24 MiB, not 80 KB. Charging the delta is what let a tick overrun its budget
-     * by an order of magnitude.
-     */
-    bytesRead: number;
-}
-/**
- * Fold one session's new transcript bytes and return the entry to cache.
- * Exported for tests: this is where the resume decision and the whole-file
- * fallback live, and both are worth pinning without a daemon.
- *
- * `byteBudget` is the TICK's remaining allowance. Each branch derives its own
- * ceiling from it — the resumable chunk read is additionally capped per session,
- * while a whole-file re-parse is gated on a budget that can actually reach a
- * real transcript. A session that genuinely does not fit gets a `partial` row
- * stating why, never silence.
- */
-export declare function foldSessionTimeline(session: ActiveSession, filePath: string, fileSize: number, prior: SessionTimelineCacheRow | undefined, nowMs?: number, byteBudget?: number): SessionTimelineFold | undefined;
 /**
  * Fold the timelines of the live local sessions, bounded, once per tick.
  * Returns what it did so the daemon tick can log it like every other pass.
@@ -127,3 +87,4 @@ export declare function runTimelinePass(opts?: TimelinePassOptions): Promise<Tim
 export declare function runTimelinePassSync(opts: TimelinePassOptions & {
     sessions: ActiveSession[];
 }): TimelinePassResult;
+export {};

package/dist/lib/session/timeline-pass.js

@@ -24,7 +24,7 @@ import { parseClaudeContent, parseCodexItemsContent, parseSession } from './pars
 import { toolEvidenceSourcePath } from './tool-store.js';
 import { compactTimelineState, emptyTimelineState, foldTimeline, projectSessionFiles, projectTimeline, unavailableTimeline, TIMELINE_EXTRACTOR_VERSION, } from './timeline.js';
 /** Sessions folded per tick. The tick's own deadline is 30 s; this stays well inside it. */
-export const TIMELINE_PASS_MAX_PER_TICK = 8;
+const TIMELINE_PASS_MAX_PER_TICK = 8;
 /** Bytes one session may consume in one tick. A bigger backlog catches up over ticks. */
 export const TIMELINE_PASS_MAX_BYTES_PER_SESSION = 4 * 1024 * 1024;
 /**
@@ -36,7 +36,7 @@ export const TIMELINE_PASS_MAX_BYTES_PER_SESSION = 4 * 1024 * 1024;
  * the service on this fleet (observed 2026-09-06). A tick budget makes a cold
  * start catch up over a few ticks instead of stalling one.
  */
-export const TIMELINE_PASS_MAX_BYTES_PER_TICK = 8 * 1024 * 1024;
+const TIMELINE_PASS_MAX_BYTES_PER_TICK = 8 * 1024 * 1024;
 /**
  * Ceiling on a whole-file re-parse for a harness with no resumable reader.
  * Beyond it the timeline is reported `partial` rather than wedging the tick —
@@ -44,7 +44,7 @@ export const TIMELINE_PASS_MAX_BYTES_PER_TICK = 8 * 1024 * 1024;
  */
 export const TIMELINE_PASS_MAX_WHOLE_FILE_BYTES = 16 * 1024 * 1024;
 /** Events folded from one non-resumable whole-file parse before reporting `partial`. */
-export const TIMELINE_PASS_MAX_EVENTS = 20_000;
+const TIMELINE_PASS_MAX_EVENTS = 20_000;
 /**
  * How long a non-resumable harness's timeline may go stale before the pass
  * re-parses its transcript whole.
@@ -139,7 +139,7 @@ function mib(bytes) {
  * real transcript. A session that genuinely does not fit gets a `partial` row
  * stating why, never silence.
  */
-export function foldSessionTimeline(session, filePath, fileSize, prior, nowMs = Date.now(), byteBudget = TIMELINE_PASS_MAX_BYTES_PER_TICK) {
+function foldSessionTimeline(session, filePath, fileSize, prior, nowMs = Date.now(), byteBudget = TIMELINE_PASS_MAX_BYTES_PER_TICK) {
     const agent = (session.kind ?? 'claude');
     // A settled state stamped at the file's current size, so an unavailable or
     // over-limit session is recognized as up to date next tick instead of being

package/dist/lib/session/timeline.d.ts

@@ -33,16 +33,6 @@ import type { SessionEvent, SessionFileChange, SessionFiles, SessionRequest, Ses
 export declare const TIMELINE_EXTRACTOR_VERSION = 1;
 /** Steps carried on the row in full; everything older folds into a counter. */
 export declare const TIMELINE_KEEP_STEPS = 8;
-/** File rows carried on the row in full; `total` still reports the real count. */
-export declare const TIMELINE_KEEP_FILES = 8;
-/**
- * Steps kept in the persisted resume state. A long session narrates for hours,
- * and the state is re-read every tick, so the fold rolls everything past this
- * into {@link TimelineState.dropped} — exact totals, bounded bytes.
- */
-export declare const TIMELINE_STATE_MAX_STEPS = 200;
-/** Paths kept in the persisted resume state; older ones roll into `filesDropped`. */
-export declare const TIMELINE_STATE_MAX_FILES = 200;
 /** One file the session touched, as accumulated during the fold. */
 interface TimelineFileEntry {
     op: SessionFileChange['op'];
@@ -115,7 +105,7 @@ export declare function classifyCommandVerb(command: string | undefined): Sessio
 /** The verb class for one tool call: the harness's own if it classified it, else derived. */
 export declare function verbClassForEvent(event: SessionEvent): SessionVerbClass;
 /** Options the fold needs that are not on the events themselves. */
-export interface FoldTimelineOptions {
+interface FoldTimelineOptions {
     /** Row attachments, so an image the prose never named still rides the request. */
     attachments?: import('./types.js').SessionAttachment[];
     /** Stop after this many events and mark the state `truncated` (the projection reads `partial`). */
@@ -135,9 +125,9 @@ export interface FoldTimelineOptions {
  */
 export declare function foldTimeline(events: SessionEvent[], prior?: TimelineState, opts?: FoldTimelineOptions): TimelineState;
 /** The activity values that mean the agent is mid-step, so the newest step is live. */
-export type TimelineActivity = string | undefined;
+type TimelineActivity = string | undefined;
 /** How {@link projectTimeline} scrubs the transcript text it is about to ship. */
-export interface ProjectTimelineOptions {
+interface ProjectTimelineOptions {
     /** Redact secrets from every projected string. Default true — see below. */
     redact?: boolean;
     /** Known credential values to mask verbatim; defaults to {@link knownSecretValuesFromEnv}. */

package/dist/lib/session/timeline.js

@@ -36,15 +36,15 @@ export const TIMELINE_EXTRACTOR_VERSION = 1;
 /** Steps carried on the row in full; everything older folds into a counter. */
 export const TIMELINE_KEEP_STEPS = 8;
 /** File rows carried on the row in full; `total` still reports the real count. */
-export const TIMELINE_KEEP_FILES = 8;
+const TIMELINE_KEEP_FILES = 8;
 /**
  * Steps kept in the persisted resume state. A long session narrates for hours,
  * and the state is re-read every tick, so the fold rolls everything past this
  * into {@link TimelineState.dropped} — exact totals, bounded bytes.
  */
-export const TIMELINE_STATE_MAX_STEPS = 200;
+const TIMELINE_STATE_MAX_STEPS = 200;
 /** Paths kept in the persisted resume state; older ones roll into `filesDropped`. */
-export const TIMELINE_STATE_MAX_FILES = 200;
+const TIMELINE_STATE_MAX_FILES = 200;
 /** A narration beat that said nothing and ran nothing merges into the next one within this window. */
 const NARRATION_MERGE_MS = 2_000;
 /** A thinking block shorter than this is a fragment, not a beat worth showing. */

package/dist/lib/session/tool-calls.d.ts

@@ -8,7 +8,6 @@ export declare const TOOL_PENDING_MAX_BYTES: number;
 export declare const TOOL_PENDING_MAX_CALLS = 256;
 export declare const TOOL_CHANGED_MAX_CALLS = 10000;
 export declare const TOOL_INDEX_LIMIT_ORDINAL: number;
-export declare const TOOL_TEXT_PROCESSING_MAX_BYTES: number;
 export declare const TOOL_SHELL_PARSE_MAX_BYTES: number;
 export declare const TOOL_INDEX_VERSION = 9;
 export type ToolCallOutcome = 'ok' | 'error' | 'unknown';
@@ -97,7 +96,7 @@ export interface EventToolScanResumePoint {
     /** How many events had been folded when the snapshot was taken. */
     eventCount: number;
 }
-export interface EventToolScanResult {
+interface EventToolScanResult {
     /** The CHANGED calls — an append-safe upsert set, not the whole history. */
     calls: IndexedToolCall[];
     /** Serialized-ready snapshot to persist for the next incremental scan. */
@@ -130,3 +129,4 @@ export declare function toolCallKey(sessionId: string, ordinal: number): string;
 export declare function collectClaudeToolCalls(collector: ToolCallCollector, parsed: any): void;
 /** Fold one raw Codex rollout record into the resumable call collector. */
 export declare function collectCodexToolCalls(collector: ToolCallCollector, parsed: any): void;
+export {};

package/dist/lib/session/tool-calls.js

@@ -10,7 +10,7 @@ export const TOOL_PENDING_MAX_BYTES = 1024 * 1024;
 export const TOOL_PENDING_MAX_CALLS = 256;
 export const TOOL_CHANGED_MAX_CALLS = 10_000;
 export const TOOL_INDEX_LIMIT_ORDINAL = Number.MAX_SAFE_INTEGER;
-export const TOOL_TEXT_PROCESSING_MAX_BYTES = 64 * 1024;
+const TOOL_TEXT_PROCESSING_MAX_BYTES = 64 * 1024;
 export const TOOL_SHELL_PARSE_MAX_BYTES = 64 * 1024;
 // Bumped to 9 for Codex tool-outcome classification (PHNX-3761): Codex results
 // arrive as a string or input_text[] rather than an object, so every one used to

package/dist/lib/session/tool-index.d.ts

@@ -6,7 +6,6 @@ export declare const TOOL_PROGRAM_COUNT_SCHEMA_VERSION = 1;
 export declare const TOOL_QUERY_MAX_CLAUSES = 32;
 export declare const TOOL_QUERY_MAX_CLAUSE_BYTES = 4096;
 export declare const TOOL_QUERY_MAX_CALL_ROWS = 50000;
-export declare const TOOL_QUERY_MAX_RESULT_BYTES: number;
 export declare const TOOL_QUERY_MAX_RESULT_SESSIONS = 1000;
 export declare const TOOL_QUERY_MAX_SERIALIZED_BYTES: number;
 export declare const TOOL_QUERY_MERGE_OVERHEAD_BYTES: number;
@@ -90,16 +89,9 @@ export declare function ensureToolIndex(sessions: SessionMeta[], limits?: {
     maxBytes?: number;
     verifySourceStamps?: boolean;
 }): Promise<ToolIndexCoverage>;
-interface QueryTerm {
-    field?: 'tool' | 'program' | 'input' | 'output' | 'status' | 'exit' | 'error';
-    value: string;
-}
-/** Parse one same-call clause. Unprefixed terms search every evidence field. */
-export declare function parseToolQueryClause(source: string): QueryTerm[];
 /** A count has one unambiguous subject: one exact `program:<name>` term. */
 export declare function parseToolProgramCountClause(source: string): string;
 /** Count exact, pre-indexed static program sites without reading transcripts. */
 export declare function countToolProgramOccurrences(sessions: SessionMeta[], program: string, coverage: ToolIndexCoverage, machine: string): ToolProgramCountEnvelope;
 /** Query cached evidence; every repeated clause must select a distinct call. */
 export declare function searchToolCalls(sessions: SessionMeta[], clauseSources: string[], coverage: ToolIndexCoverage, resultLimit?: number): ToolSearchEnvelope;
-export {};

package/dist/lib/session/tool-index.js

@@ -14,7 +14,7 @@ export const TOOL_PROGRAM_COUNT_SCHEMA_VERSION = 1;
 export const TOOL_QUERY_MAX_CLAUSES = 32;
 export const TOOL_QUERY_MAX_CLAUSE_BYTES = 4096;
 export const TOOL_QUERY_MAX_CALL_ROWS = 50_000;
-export const TOOL_QUERY_MAX_RESULT_BYTES = 8 * 1024 * 1024;
+const TOOL_QUERY_MAX_RESULT_BYTES = 8 * 1024 * 1024;
 export const TOOL_QUERY_MAX_RESULT_SESSIONS = 1_000;
 export const TOOL_QUERY_MAX_SERIALIZED_BYTES = 15 * 1024 * 1024;
 export const TOOL_QUERY_MERGE_OVERHEAD_BYTES = 64 * 1024;
@@ -400,7 +400,7 @@ function tokenizeClause(source) {
     return tokens;
 }
 /** Parse one same-call clause. Unprefixed terms search every evidence field. */
-export function parseToolQueryClause(source) {
+function parseToolQueryClause(source) {
     const fields = new Set(['tool', 'program', 'input', 'output', 'status', 'exit', 'error']);
     return tokenizeClause(source).map((token) => {
         const colon = token.indexOf(':');

package/dist/lib/session/tool-store.d.ts

@@ -22,7 +22,7 @@ export interface ToolScanResumePoint {
      */
     parsedOffset: number;
 }
-export interface PersistToolCallsOptions {
+interface PersistToolCallsOptions {
     /**
      * `replace` drops the session's stored evidence first — correct for a parse
      * that started at byte 0. `append` merges the batch into what is already
@@ -68,3 +68,4 @@ export declare function planEventToolResume(db: Database.Database, sessionId: st
     fileMtimeMs: number;
     fileSize: number;
 }, currentEventCount: number): EventToolScanResumePoint | null;
+export {};

package/dist/lib/session/trajectory-compare.d.ts

@@ -35,7 +35,7 @@ export interface TrajectoryComparison {
     truncatedA: number;
     truncatedB: number;
 }
-export interface DiffTrajectoriesOptions {
+interface DiffTrajectoriesOptions {
     /** Cap on tool steps considered per side (the LCS table is O(n*m)). Default 1000. */
     maxDiffSteps?: number;
 }
@@ -45,3 +45,4 @@ export interface DiffTrajectoriesOptions {
  * did. Never mutates either input.
  */
 export declare function diffTrajectories(a: SessionTrajectory, b: SessionTrajectory, options?: DiffTrajectoriesOptions): TrajectoryComparison;
+export {};

package/dist/lib/session/trajectory-lineage.d.ts

@@ -65,7 +65,7 @@ export interface SessionLineage {
      */
     unresolvedParentIds: string[];
 }
-export interface BuildLineageOptions {
+interface BuildLineageOptions {
     /**
      * Which session the graph is about. The graph is always rooted at that
      * session's TOPMOST ancestor in the pool, so passing a child still renders its
@@ -90,3 +90,4 @@ export interface BuildLineageOptions {
  * sessions in the pool supply edges but never become nodes.
  */
 export declare function buildLineage(sessions: SessionMeta[], options?: BuildLineageOptions): SessionLineage;
+export {};

package/dist/lib/session/trajectory-text.d.ts

@@ -1,7 +1,7 @@
 import type { SessionTrajectory } from './trajectory.js';
 import type { TrajectoryComparison } from './trajectory-compare.js';
 import type { SessionLineage } from './trajectory-lineage.js';
-export interface RenderTrajectoryTextOptions {
+interface RenderTrajectoryTextOptions {
     /** Collapse to error steps and their immediate neighbours. */
     errorsOnly?: boolean;
     /** Cap on the step lines emitted; the remainder is collapsed with a count. */
@@ -9,7 +9,7 @@ export interface RenderTrajectoryTextOptions {
 }
 /** Render one session's trajectory as compact, ANSI-free text. */
 export declare function renderTrajectoryText(model: SessionTrajectory, options?: RenderTrajectoryTextOptions): string;
-export interface RenderTrajectoryCompareTextOptions {
+interface RenderTrajectoryCompareTextOptions {
     /** Cap on step lines listed per diff column; the remainder is collapsed with a count. Default 15. */
     maxDiffLines?: number;
 }
@@ -35,3 +35,4 @@ export declare function renderTrajectoryCompareText(cmp: TrajectoryComparison, o
  * the shape of the fan-out; `agents sessions trace <child>` answers one child.
  */
 export declare function renderLineageText(lineage: SessionLineage): string;
+export {};

package/dist/lib/session/trajectory.d.ts

@@ -80,7 +80,7 @@ export interface SessionTrajectory {
     /** Steps dropped by the `maxSteps` cap, surfaced so truncation is never silent. */
     truncatedSteps: number;
 }
-export interface BuildTrajectoryOptions {
+interface BuildTrajectoryOptions {
     /** Redact derived labels/details (default true; `--no-redact` is local-only). */
     redact?: boolean;
     /** Known secret values to mask, from `knownSecretValuesFromEnv()`. */
@@ -142,3 +142,4 @@ export declare function pairSteps(events: SessionEvent[], eventMs: number[], fir
  * event array and therefore an empty trajectory — never a crash or a fabricated one.
  */
 export declare function buildTrajectory(events: SessionEvent[], meta: SessionMeta, options?: BuildTrajectoryOptions): SessionTrajectory;
+export {};

package/dist/lib/session/viewing-in.d.ts

@@ -21,7 +21,7 @@ import type { TmuxClient } from '../tmux/session.js';
 import type { ActiveSession } from './active.js';
 import { type GhosttySurface } from './ghostty-tabs.js';
 /** Where a tmux-hosted session is currently displayed. */
-export interface ViewingIn {
+interface ViewingIn {
     /** Host app of the attached client — 'ghostty', 'iterm', 'code', 'codium', … */
     app: string;
     /** 1-based tab number within that app, when it can be resolved. */
@@ -83,3 +83,4 @@ export declare function resolveViewingIn(session: ActiveSession, clients: TmuxCl
  * Ghostty's `index of tab`. Exported for the parser test.
  */
 export declare function itermTabFromSessionId(value: string | undefined): number | undefined;
+export {};

package/dist/lib/settings-manifest.d.ts

@@ -17,7 +17,7 @@
  * `hasTrustDialogAccepted: false` to `true` — see the note on that entry.)
  */
 import type { AgentId } from './types.js';
-export interface CarryForwardResult {
+interface CarryForwardResult {
     /** Manifest rel paths that were created or updated in the target home. */
     applied: string[];
     /** Backup directory holding pre-merge copies of modified target files, if any. */
@@ -39,3 +39,4 @@ export declare function fillGaps(target: Record<string, unknown>, source: Record
  * Only fills gaps — never overwrites target values — so it is idempotent.
  */
 export declare function carryForwardSettings(agent: AgentId, fromHome: string, toHome: string): CarryForwardResult;
+export {};

package/dist/lib/share/delete.d.ts

@@ -18,11 +18,11 @@ export type RevisionsFetchFn = (url: string) => Promise<{
     contentType: string;
     body: string;
 }>;
-export interface DeleteEndpoint {
+interface DeleteEndpoint {
     baseUrl: string;
     token: string;
 }
-export interface ResolvedShareTarget {
+interface ResolvedShareTarget {
     /** R2 object key for the page, `<user>/<slug>`. */
     key: string;
     /** R2 object key for the sibling OG cover, `<user>/<slug>.png`. */
@@ -45,7 +45,7 @@ export interface ResolvedShareTarget {
 export declare function resolveDeleteTarget(target: string, opts?: {
     githubUser?: string;
 }): Promise<ResolvedShareTarget>;
-export interface DeleteObjectResult {
+interface DeleteObjectResult {
     key: string;
     url: string;
     /** Whether the object resolved (non-404) before the DELETE was issued. */
@@ -66,7 +66,7 @@ export declare function deleteObject(endpoint: DeleteEndpoint, key: string, opts
     deleter?: DeleteFn;
     checker?: CheckFn;
 }): Promise<DeleteObjectResult>;
-export interface DeleteShareOptions {
+interface DeleteShareOptions {
     /** Skip deleting the sibling `<slug>.png` OG cover (default: delete it too). */
     keepCover?: boolean;
     /** Skip deleting the target's retained revisions (`<key>/rev-*`, RUSH-2683
@@ -120,3 +120,4 @@ export interface DeleteShareResult {
  * are gone. Throws on an unverified takedown — never reports success for an
  * object that still resolves. */
 export declare function deleteShare(target: string, opts?: DeleteShareOptions): Promise<DeleteShareResult>;
+export {};

package/dist/lib/share/html.d.ts

@@ -10,8 +10,6 @@
  * left alone. This is not a bundler — it only fixes what would otherwise
  * render as a broken page after a single-file publish.
  */
-/** Skip inlining a sibling that would bloat the page past a reasonable PUT. */
-export declare const MAX_INLINE_BYTES: number;
 /**
  * `href="file:///tmp/page.html#purpose"` → `href="#purpose"`.
  * Bare `file:///tmp/page.html` (no hash) becomes `href="#"`.

package/dist/lib/share/html.js

@@ -14,7 +14,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import { dirname, extname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 /** Skip inlining a sibling that would bloat the page past a reasonable PUT. */
-export const MAX_INLINE_BYTES = 4 * 1024 * 1024;
+const MAX_INLINE_BYTES = 4 * 1024 * 1024;
 const IMAGE_MIME = {
     '.png': 'image/png',
     '.jpg': 'image/jpeg',
@@ -32,15 +32,15 @@ const IMAGE_MIME = {
 export function rewriteFileAnchors(html) {
     return html.replace(/\b(href\s*=\s*["'])file:\/\/[^"'#]*(#[^"']*)?(["'])/gi, (_m, attr, hash, quote) => `${attr}${hash ?? '#'}${quote}`);
 }
+/**
+ * Only a bare path or a `file:` URL can name a local asset; every other scheme
+ * is left alone. A single-letter "scheme" is a Windows drive (`C:\\x.png`), not a URL.
+ */
 function isRemoteOrSpecial(url) {
-    return (url.startsWith('data:') ||
-        url.startsWith('http://') ||
-        url.startsWith('https://') ||
-        url.startsWith('//') ||
-        url.startsWith('#') ||
-        url.startsWith('mailto:') ||
-        url.startsWith('javascript:') ||
-        url.startsWith('agents:'));
+    if (url.startsWith('//') || url.startsWith('#'))
+        return true;
+    const scheme = /^([a-z][a-z0-9+.-]*):/i.exec(url)?.[1];
+    return scheme !== undefined && scheme.length > 1 && scheme.toLowerCase() !== 'file';
 }
 function localImagePath(url, htmlDir) {
     if (!url || isRemoteOrSpecial(url))

package/dist/lib/share/http-error.d.ts

@@ -16,7 +16,7 @@
  */
 /** The raw pieces a caller's fetch wrapper hands in — status plus the (optional)
  * response body text and `Retry-After` header value. */
-export interface ShareHttpResponse {
+interface ShareHttpResponse {
     status: number;
     /** The response body text, when the caller read it (only on `!ok` paths). */
     body?: string;
@@ -25,7 +25,7 @@ export interface ShareHttpResponse {
 }
 /** The extracted, bounded error facts. `serverMessage` is present only when the
  * body parsed as JSON carrying a non-empty string `error`. */
-export interface ShareHttpError {
+interface ShareHttpError {
     status: number;
     serverMessage?: string;
     retryAfter?: string;
@@ -50,3 +50,4 @@ export declare function extractShareHttpError(res: ShareHttpResponse): ShareHttp
  *   → `Publish failed (429) for <url> — rate limit exceeded; retry after 37s`
  */
 export declare function formatShareHttpErrorDetail(err: ShareHttpError): string;
+export {};

package/dist/lib/share/og.d.ts

@@ -7,7 +7,7 @@
  * previously added before re-inserting). Pure string work so it's unit-testable
  * without a browser or network.
  */
-export interface OgFields {
+interface OgFields {
     title: string;
     description: string;
     imageUrl: string;
@@ -23,3 +23,4 @@ export declare function deriveMeta(html: string, fallbackTitle?: string): {
 };
 /** Splice OG + Twitter tags into `<head>` (or prepend if there's no head). Idempotent. */
 export declare function injectOgMeta(html: string, f: OgFields): string;
+export {};

package/dist/lib/share/provision.d.ts

@@ -55,7 +55,7 @@ export declare function deployWorker(apiToken: string, accountId: string, worker
 /** sha256 of the rendered Worker script, so a deployed endpoint can be compared
  * against the current `worker-template.ts` without redeploying to find out. */
 export declare function hashWorkerScript(script: string): string;
-export interface UpdateWorkerResult {
+interface UpdateWorkerResult {
     /** sha256 of `script` (the hash the endpoint now matches, whether or not this
      * call actually redeployed). */
     templateHash: string;
@@ -68,7 +68,7 @@ export declare const WORKER_PHOENIX_ID_BASE_SECRET = "PHOENIX_ID_BASE";
 export declare const WORKER_COLLAB_BASE_SECRET = "PRIX_ARTIFACT_COLLAB_BASE";
 /** Cloudflare `secret_text` name the Worker reads as `env.ARTIFACT_COLLAB_SERVICE_TOKEN`. */
 export declare const WORKER_COLLAB_SERVICE_TOKEN_SECRET = "ARTIFACT_COLLAB_SERVICE_TOKEN";
-export type UpdateWorkerOpts = ProvisionOptions & {
+type UpdateWorkerOpts = ProvisionOptions & {
     force?: boolean;
     /**
      * Phoenix ID base URL to bind as `PHOENIX_ID_BASE` after the script upload.

package/dist/lib/share/publish.d.ts

@@ -5,7 +5,7 @@ import { type ShareVisibility } from '../storage/visibility.js';
  * response so a failed publish can surface WHY (the Worker returns
  * `{"error":"…"}` + a `Retry-After` on a 429); they are read only on `!ok`
  * paths, and only ever fed through the bounded {@link extractShareHttpError}. */
-export type PutResult = {
+type PutResult = {
     ok: boolean;
     status: number;
     url?: string;
@@ -15,7 +15,7 @@ export type PutResult = {
     retryAfter?: string;
 };
 export type PutFn = (url: string, body: Buffer, headers: Record<string, string>) => Promise<PutResult>;
-export interface PublishEndpoint {
+interface PublishEndpoint {
     baseUrl: string;
     token: string;
 }
@@ -163,18 +163,9 @@ export declare function resolveShareVisibility(opts?: {
     unlisted?: boolean;
     protected?: boolean;
 }): ShareVisibility;
-/** Mint a fresh random viewer token for a `private` (token-gated) publish. The
- * raw token rides ONLY in the returned URL's `?k=`; the Worker stores just its
- * SHA-256 hash, so the object metadata never carries the secret. */
-export declare function generateViewerToken(): string;
 /** SHA-256 hex of a viewer token — the form the Worker also computes and stores,
  * so a CLI-side preview of the stored hash matches. Exported for tests. */
 export declare function hashViewerToken(token: string): string;
-/** A 64-bit random slug tail (16 lowercase hex chars) for a capability-URL
- * publish, so the slug can never be derived/guessed from the title (PHNX-3654).
- * `unlisted` leans on this for obscurity; `private` uses it as defense-in-depth
- * behind the viewer token. */
-export declare function randomSlugTail(): string;
 /**
  * The loud stderr warning printed on an `unlisted` / `--private` publish
  * (PHNX-3654): `unlisted` is obscurity, NOT read-authentication — anyone with
@@ -312,8 +303,8 @@ export declare function parseExpire(spec: string | undefined): string | undefine
  * `never` / `none` / `permanent` → no expiry. Anything else → {@link parseExpire}.
  */
 export declare function resolveExpire(spec: string | undefined): string | undefined;
-export type SensitiveHitKind = 'email' | 'credential';
-export interface SensitiveHit {
+type SensitiveHitKind = 'email' | 'credential';
+interface SensitiveHit {
     kind: SensitiveHitKind;
     /** Short redacted sample so the error names *what* was found without dumping it. */
     sample: string;

package/dist/lib/share/publish.js

@@ -53,7 +53,7 @@ const VIEWER_TOKEN_BYTES = 16;
 /** Mint a fresh random viewer token for a `private` (token-gated) publish. The
  * raw token rides ONLY in the returned URL's `?k=`; the Worker stores just its
  * SHA-256 hash, so the object metadata never carries the secret. */
-export function generateViewerToken() {
+function generateViewerToken() {
     return randomBytes(VIEWER_TOKEN_BYTES).toString('base64url');
 }
 /** SHA-256 hex of a viewer token — the form the Worker also computes and stores,
@@ -65,7 +65,7 @@ export function hashViewerToken(token) {
  * publish, so the slug can never be derived/guessed from the title (PHNX-3654).
  * `unlisted` leans on this for obscurity; `private` uses it as defense-in-depth
  * behind the viewer token. */
-export function randomSlugTail() {
+function randomSlugTail() {
     return randomBytes(8).toString('hex');
 }
 /**

package/dist/lib/shim-heal.d.ts

@@ -1,5 +1,5 @@
 import type { SelfHealReport } from './self-heal/types.js';
-export interface InteractiveShimHealResult {
+interface InteractiveShimHealResult {
     noticeLines: string[] | null;
     report: SelfHealReport;
 }
@@ -9,10 +9,6 @@ export interface InteractiveShimHealResult {
  * won't move; a PATH entry that was just added / needs a reload).
  */
 export declare function runInteractiveShimHeal(): Promise<InteractiveShimHealResult>;
-/**
- * Back-compat wrapper for callers that only need the persistent one-time notice.
- */
-export declare function healShimsInteractive(): Promise<string[] | null>;
 type PathNoticeState = 'ok' | 'added' | 'reload';
 /**
  * A stable signature of the conditions worth surfacing: the sorted set of

package/dist/lib/shim-heal.js

@@ -54,12 +54,6 @@ export async function runInteractiveShimHeal() {
     }
     return { noticeLines: lines.length > 0 ? lines : null, report };
 }
-/**
- * Back-compat wrapper for callers that only need the persistent one-time notice.
- */
-export async function healShimsInteractive() {
-    return (await runInteractiveShimHeal()).noticeLines;
-}
 function noticeStatePath() {
     return path.join(getRuntimeStateDir(), 'shim-notice.json');
 }