sourcemonkey 0.0.0-stage → 0.5.0

package/lib/sm-dev-protocol.d.ts

@@ -0,0 +1,251 @@
+import type { PendingOnDisk } from './script-display.js';
+/** The first argument of every event's console line. */
+export declare const SM_DEV_EVENT = "sm-dev-event";
+/**
+ * Refusals of the `managed` calls (managed-changes.ts), which sm-dev
+ * also checks before asking for `--force`.
+ */
+export declare const RUN_COLLECTION_LOCKED = "An sm-dev run's test collection is changed only by its run";
+export declare const LISTED_BY_LOCATION = "This script is listed by a directory or manifest collection, so it stays there while its file does. Only a script in a container collection can be moved or uninstalled.";
+export declare const CONTAINER_TARGET_ONLY = "Scripts can only be installed or moved into a container collection";
+/**
+ * Why a manual script (`@run-at context-menu`) can't be run on a tab
+ * now: `runManualScript`'s answers, which the popup logs and sm-dev
+ * prints after the script's name. See docs/manual-scripts.md.
+ */
+export declare const MANUAL_RUN_NOT_INSTALLED = "This script is not installed";
+export declare const MANUAL_RUN_NOT_MANUAL = "This script runs when a page loads. Only a script with @run-at context-menu is run on request.";
+export declare const MANUAL_RUN_SCRIPT_OFF = "This script is turned off";
+export declare const MANUAL_RUN_COLLECTION_OFF = "This script's collection is turned off";
+export declare const MANUAL_RUN_NOT_HERE = "This script's @match and @include rules don't cover this page";
+export declare const MANUAL_RUN_PAGE = "SourceMonkey can't run scripts on this page";
+export declare const MANUAL_RUN_TAB_GONE = "The tab was closed";
+export declare const MANUAL_RUN_PAGE_CHANGED = "The page changed before the script could run. Try again.";
+export declare const MANUAL_RUN_SM_DEV = "The sm-dev run controlling this tab keeps this script out";
+/**
+ * The event types of the markers sm-dev puts in its browser's pages,
+ * which tell a `document-start` wrapper whether it can run without
+ * asking the extension (`smDevMarker` in userscript-prelude.js, which
+ * has its own copy). See docs/sm-dev-design.md#making-wrappers-ask.
+ * - `present`: in every page. sm-dev is connected, so any tab may be
+ *   claimed.
+ * - `vouchPrefix` + the run's id: in a tab that run claims, while its
+ *   scripts are on.
+ */
+export declare const SM_DEV_MARKERS: {
+    readonly present: "sourcemonkey-sm-dev";
+    readonly vouchPrefix: "sourcemonkey-sm-dev-run:";
+};
+/** The reason a skipped wrapper reports for a tab an sm-dev run controls. */
+export declare const SKIP_REASON_SM_DEV = "tab controlled by sm-dev";
+/**
+ * The version of the calls and events between sm-dev and the extension,
+ * which each side has its own copy of: sm-dev from a repo's install, the
+ * extension from the person's browser. A run compares them as it
+ * connects (extension-link.ts). See CLAUDE.md for when to bump which.
+ *   - `major`: a change that needs both sides updated. A run refuses an
+ *     extension whose major differs.
+ *   - `minor`: an addition. An extension ahead is fine. An sm-dev ahead
+ *     checks the extension's minor before using what came later
+ *     (`ExtensionLink.requireMinor`).
+ */
+export declare const SM_DEV_PROTOCOL: {
+    readonly major: 3;
+    readonly minor: 0;
+};
+export interface ProtocolVersion {
+    major: number;
+    minor: number;
+}
+/** A collection, as the extension's `managedCollections` lists it. */
+export interface ManagedCollection {
+    /** The extension's own id for it. */
+    id: string;
+    /** Its number (sm-dev's `C3`); absent for a run's test collection. */
+    number?: number;
+    name: string;
+    kind: 'container' | 'directory' | 'manifest';
+    /** A directory's or manifest's location; none for a container. */
+    location?: string;
+    /** A run's test collection: the run's id in the extension (`D1-ab12`). */
+    run?: string;
+    enabled: boolean;
+    /** Why its last scan failed. */
+    error?: string;
+    scriptCount: number;
+}
+/** An installed script, as the extension's `managedScripts` lists it. */
+export interface ManagedScript {
+    /** The extension's own id for it. */
+    id: string;
+    /**
+     * Its number (sm-dev's `E12`); absent in a run's test collection, and
+     * until the worker gives it one.
+     */
+    number?: number;
+    name: string;
+    namespace?: string;
+    version?: string;
+    /** Where it is loaded from: for a run's script, its `scratch:` URL. */
+    location: string;
+    /** A run's script: the file it was read from, as a `file://` URL. */
+    sourceFile?: string;
+    /** A run's script: its path as the run was given it, often relative. */
+    loadedAs?: string;
+    collectionId: string;
+    enabled: boolean;
+    status: 'ok' | 'invalid';
+    /** Why it is invalid. */
+    error?: string;
+    /** Why its last refresh failed, while its last good copy still runs. */
+    refreshError?: string;
+    /**
+     * Set by sm-dev, under another manager (external-manager.ts): a
+     * run's script, whose run is live (`D1`).
+     */
+    run?: string;
+    /** Set by sm-dev, under another manager: a run's script, left by that run when it ended (`D1`). */
+    leftBy?: string;
+}
+/** A `@require` or `@resource`, as `managed.scriptDetails` gives it. */
+export interface ManagedFile {
+    /** As the header gives it. */
+    url: string;
+    /** `@resource`'s name. */
+    name?: string;
+    /** Loaded, or not: a script that failed to load has none. Absent when the manager doesn't say. */
+    loaded?: boolean;
+    /** The local file read in its place. */
+    local?: string;
+}
+/**
+ * A `@require` or `@resource` file's installed contents, for `script
+ * print --file` and `script save` (`managed.scriptFiles`). sm-dev puts
+ * a script's `@icon` in this shape too.
+ */
+export interface ManagedFileContent {
+    kind: 'require' | 'resource' | 'icon';
+    /** Its URL, resolved. */
+    url: string;
+    /** `@resource`'s name. */
+    name?: string;
+    /**
+     * Where `script save` writes it, relative to the script: an http(s)
+     * URL's `<host>/<path>`, as the viewer's local copy lays it out, or a
+     * `file:` URL's file name. Absent when there is none (a `data:` URL).
+     */
+    path?: string;
+    /** Its bytes. */
+    base64: string;
+    contentType?: string;
+}
+/** A script's icons, for `script show`, `print` and `save` (`managed.scriptIcons`). */
+export interface ManagedScriptIcons {
+    /** Its own `@icon` (or an alias); absent for none. */
+    icon?: {
+        /** Resolved against the script's own location. */
+        url: string;
+        /** Where `script save` writes it, as `ManagedFileContent.path`. */
+        path?: string;
+        /** The local file that stands in for it, as for a `@require`. */
+        local?: string;
+        /** Its bytes, when asked to load them and they could be read. */
+        base64?: string;
+        contentType?: string;
+    };
+    /**
+     * The site icons a page heading shows for it, merged and in order.
+     * Absent when not all were in the cache and it wasn't asked to load
+     * them.
+     */
+    siteIcons?: ManagedSiteIcon[];
+}
+/** What `managed.scriptIcons` reads or looks up, beyond what it has at hand. */
+export interface ScriptIconsLoad {
+    icon?: boolean;
+    sites?: boolean;
+}
+/**
+ * Where a discovered site icon came from: Chrome's `/_favicon/` DB, the
+ * page's `<link rel="icon">`, the site's `/favicon.ico`, or Google S2.
+ */
+export type IconSource = 'favicon-store' | 'page' | 'favicon.ico' | 'google';
+/** One of a script's site icons: absent bytes for the globe (none found). */
+export interface ManagedSiteIcon {
+    /** The sites it stands for, by the URL its icon links to, its own first. */
+    sites: string[];
+    /**
+     * What `script save` names it, without the extension: its site's
+     * host (`github.com`), with the page's path when the icon is that
+     * page's own (`npmjs.com/package`).
+     */
+    name: string;
+    /** Where it came from; absent for an icon cached before that was kept. */
+    source?: IconSource;
+    base64?: string;
+    contentType?: string;
+}
+/** An installed script in full, for `script show` (`managed.scriptDetails`). */
+export interface ManagedScriptDetails extends ManagedScript {
+    description?: string;
+    author?: string;
+    /** When its current text was loaded, in epoch ms; absent if never. */
+    updatedAt?: number;
+    match: string[];
+    include: string[];
+    exclude: string[];
+    excludeMatch: string[];
+    /** As the header gives it; absent for none (`document-idle`). */
+    runAt?: string;
+    grants: string[];
+    requires: ManagedFile[];
+    resources: ManagedFile[];
+    /** Absent when the manager doesn't say. */
+    valueCount?: number;
+}
+/** What `managed.refreshScript` did. */
+export interface ScriptRefresh {
+    script: ManagedScript;
+    /** It loaded different text. */
+    updated: boolean;
+}
+/**
+ * What the disk says of the local scripts and collections, as the
+ * collections page's chips show it: `managed.onDisk`. Only those that
+ * differ are listed.
+ */
+export interface ManagedOnDisk {
+    /** By script id: its file changed, or is gone, since it was loaded. */
+    scripts: Record<string, 'modified' | 'deleted'>;
+    /** By collection id: what a refresh would load (script-display.ts). */
+    collections: Record<string, PendingOnDisk>;
+}
+/** What `managed.refreshCollection` did. */
+export interface CollectionRefresh {
+    collection: ManagedCollection;
+    /** Its scripts after: added or with different text (`updated`), unchanged, and removed (as they were). */
+    updated: ManagedScript[];
+    unchanged: number;
+    removed: ManagedScript[];
+    /**
+     * Its scripts that couldn't be refreshed, each with `refreshError`.
+     * Set by sm-dev under another manager, never sent by the extension.
+     */
+    failed?: ManagedScript[];
+}
+/**
+ * What turning a script on did: `managed.setScriptEnabled`,
+ * `moveScript` and `installScript`.
+ */
+export interface ScriptEnable {
+    script: ManagedScript;
+    /** Its other copies that were running, turned off as the viewer does. */
+    turnedOff: ManagedScript[];
+}
+/** What `managed.installScript` did. */
+export interface ScriptInstall extends ScriptEnable {
+    /** It was already installed in that collection, so nothing changed. */
+    already?: true;
+    /** Set by sm-dev, under another manager: it replaced the script with the same name and namespace. */
+    replaced?: true;
+}

package/lib/sm-dev-protocol.js

@@ -0,0 +1,84 @@
+// What the extension and sm-dev both use. Their own module so the
+// harness can name them without loading the claim code in
+// sm-dev-link.ts.
+/** The first argument of every event's console line. */
+export const SM_DEV_EVENT = 'sm-dev-event';
+/**
+ * Refusals of the `managed` calls (managed-changes.ts), which sm-dev
+ * also checks before asking for `--force`.
+ */
+export const RUN_COLLECTION_LOCKED = 'An sm-dev run\'s test collection is changed only by its run';
+export const LISTED_BY_LOCATION = 'This script is listed by a directory or manifest collection, so it stays there while its file does. Only a script in a container collection can be moved or uninstalled.';
+export const CONTAINER_TARGET_ONLY = 'Scripts can only be installed or moved into a container collection';
+/**
+ * Why a manual script (`@run-at context-menu`) can't be run on a tab
+ * now: `runManualScript`'s answers, which the popup logs and sm-dev
+ * prints after the script's name. See docs/manual-scripts.md.
+ */
+export const MANUAL_RUN_NOT_INSTALLED = 'This script is not installed';
+export const MANUAL_RUN_NOT_MANUAL = 'This script runs when a page loads. Only a script with @run-at context-menu is run on request.';
+export const MANUAL_RUN_SCRIPT_OFF = 'This script is turned off';
+export const MANUAL_RUN_COLLECTION_OFF = 'This script\'s collection is turned off';
+export const MANUAL_RUN_NOT_HERE = 'This script\'s @match and @include rules don\'t cover this page';
+export const MANUAL_RUN_PAGE = 'SourceMonkey can\'t run scripts on this page';
+export const MANUAL_RUN_TAB_GONE = 'The tab was closed';
+export const MANUAL_RUN_PAGE_CHANGED = 'The page changed before the script could run. Try again.';
+export const MANUAL_RUN_SM_DEV = 'The sm-dev run controlling this tab keeps this script out';
+/**
+ * The event types of the markers sm-dev puts in its browser's pages,
+ * which tell a `document-start` wrapper whether it can run without
+ * asking the extension (`smDevMarker` in userscript-prelude.js, which
+ * has its own copy). See docs/sm-dev-design.md#making-wrappers-ask.
+ * - `present`: in every page. sm-dev is connected, so any tab may be
+ *   claimed.
+ * - `vouchPrefix` + the run's id: in a tab that run claims, while its
+ *   scripts are on.
+ */
+export const SM_DEV_MARKERS = {
+    present: 'sourcemonkey-sm-dev',
+    vouchPrefix: 'sourcemonkey-sm-dev-run:',
+};
+/** The reason a skipped wrapper reports for a tab an sm-dev run controls. */
+export const SKIP_REASON_SM_DEV = 'tab controlled by sm-dev';
+/**
+ * The version of the calls and events between sm-dev and the extension,
+ * which each side has its own copy of: sm-dev from a repo's install, the
+ * extension from the person's browser. A run compares them as it
+ * connects (extension-link.ts). See CLAUDE.md for when to bump which.
+ *   - `major`: a change that needs both sides updated. A run refuses an
+ *     extension whose major differs.
+ *   - `minor`: an addition. An extension ahead is fine. An sm-dev ahead
+ *     checks the extension's minor before using what came later
+ *     (`ExtensionLink.requireMinor`).
+ */
+// 1.1: `scriptsOnTab` rows carry the script's number.
+// 1.2: `managedCollections` and `managedScripts`; `writeRunScript`
+//   takes the script's `source` file, which `managedScripts` gives back.
+// 1.3: permission prompts: `connect-prompt` events, `answerConnectPrompt`.
+// 1.4: a report event can carry `detail`: why a script had no decision.
+// 1.5: `managed`, the calls that change collections and installed
+//   scripts (`managed.setScriptEnabled` and the rest), and
+//   `managed.scriptDetails` / `managed.scriptText` (managed-changes.ts).
+// 1.6: manual scripts (`@run-at context-menu`): `runManualScript`, and
+//   the `sm:manual` report for one waiting in a new document.
+// 1.7: a script's badge status can be `UNTRACKED`: its page loaded
+//   before the extension started.
+// 2.0: wrappers no longer all ask while a claim is live; sm-dev marks
+//   the pages of its browser instead (`SM_DEV_MARKERS`), which an older
+//   sm-dev doesn't, so the extension would run scripts in its tabs.
+// 2.1: scripts run in iframes, so report and menu events now come from
+//   frames too (`topFrame: false`); `fireActionContextMenuItem` takes
+//   the command's `documentId`.
+// 2.2: `request`, `download`, `values` and a shown `notification` event
+//   carry the sending document's `documentId`, which says which frame.
+// 2.3: `managed.scriptFiles`, a script's `@require` and `@resource`
+//   files as installed.
+// 2.4: `managed.scriptIcons`, a script's `@icon` and its site icons.
+// 3.0: every script runs in the page's world unless it asks to be
+//   isolated. sm-dev works out each script's world itself, for
+//   `eval --script` and for whose error a page error could be, so an
+//   older one would look in the wrong world. On a page whose CSP
+//   `sandbox` turns off script in its own world, the page-world scripts
+//   run isolated instead, which sm-dev notes rather than warning that
+//   they can't run.
+export const SM_DEV_PROTOCOL = { major: 3, minor: 0 };

package/lib/source-map.d.ts

@@ -0,0 +1,32 @@
+export declare function encodeVlq(value: number): string;
+export interface MappedSegment {
+    url: string;
+    content: string;
+    generatedLine: number;
+    lineCount: number;
+}
+export interface SourceMapV3 {
+    version: 3;
+    file: string;
+    sources: string[];
+    sourcesContent: string[];
+    names: never[];
+    mappings: string;
+}
+export declare function buildSourceMap(args: {
+    file: string;
+    segments: readonly MappedSegment[];
+    totalLines: number;
+}): SourceMapV3;
+export interface OriginalPosition {
+    url: string;
+    line: number;
+}
+export declare function lookupGeneratedLine(segments: readonly MappedSegment[], generatedLine: number): OriginalPosition | null;
+export interface StackRef {
+    url: string;
+    line: number;
+    col: number;
+}
+export declare function remapStackRef(ref: StackRef, entryUrl: string, segments: readonly MappedSegment[]): StackRef | null;
+export declare function inlineSourceMapComment(map: SourceMapV3): string;

package/lib/source-map.js

@@ -0,0 +1,177 @@
+// Minimal Source Map v3 generator for the concatenated injection entry.
+//
+// Why: in Mode A (see docs/injection-modes.md) a script's `@require`
+// bodies and its own body are concatenated into ONE `js[]` entry so
+// they share a lexical scope. That's what makes a library's top-level
+// `const`/`class` visible to the main body, exactly as in TM/VM — but
+// it also means the main body's line N no longer lands at physical
+// line N, and every require loses the devtools file it used to have.
+//
+// A source map buys both back: devtools splits the single generated
+// script into the original files and reports original line numbers.
+//
+// Scope of this generator:
+//
+//   - **Line-level only.** One mapping per generated line, always at
+//     column 0. We never move code within a line, so column fidelity
+//     would be busywork; line granularity is what stack traces and
+//     breakpoints need.
+//   - **`sourcesContent` is always embedded.** Our sources are
+//     synthetic `sourcemonkey://…` URLs, which devtools cannot fetch,
+//     so embedding the text is the only way the mapped files are
+//     viewable. It is also the expensive part: the sources ship a
+//     second time, base64'd, so the entry grows by ~1.6× their size.
+//
+//     There is deliberately no size cap on this. The only constraint
+//     that actually binds is whether `chrome.userScripts.register()`
+//     accepts the payload, and that failure is already visible:
+//     `registerWithFallback` in src/extension/injector.ts drops from batch to
+//     per-script registration on rejection and records the reason
+//     against that script (which then reads REJECTED, with Chrome's
+//     wording), so an oversized script fails loudly and by name. A preemptive cap would trade that for silently degrading
+//     the feature the map exists to provide. The map does NOT touch
+//     our `chrome.storage.local` quota — it's generated at
+//     registration time from sources already stored.
+//
+// What V8 does NOT do for us: map `Error.stack` *strings*. It maps
+// source positions for the devtools UI, but `err.stack` keeps
+// generated coordinates, and SourceMonkey parses those strings for the
+// viewer's Log tab (src/stack-link.ts). `remapStackRef` below is the
+// other half — the Log tab applies the same segment list itself, so a
+// logged frame names the same file and line devtools shows. See
+// docs/script-log.md#stack-refs-are-source-mapped-first.
+// Base64 VLQ, per the Source Map v3 spec.
+const B64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+// Domain: |value| < 2^30. Above that the `<< 1` wraps negative and the
+// loop emits a single wrong digit. Every caller here passes a line or
+// source index, so this is unreachable — noted so nobody reuses the
+// function for byte offsets.
+export function encodeVlq(value) {
+    // Sign goes in the low bit, magnitude above it.
+    let vlq = value < 0 ? ((-value) << 1) | 1 : value << 1;
+    let out = '';
+    do {
+        let digit = vlq & 0b11111;
+        vlq >>>= 5;
+        // Continuation bit: more 5-bit groups follow.
+        if (vlq > 0)
+            digit |= 0b100000;
+        out += B64[digit];
+    } while (vlq > 0);
+    return out;
+}
+// Build the map object. `totalLines` is the generated entry's line
+// count; generated lines not covered by any segment (the wrap's head
+// and tail, the `;` separators) get an empty group, which devtools
+// reads as "no original position" and leaves attributed to the
+// generated file.
+//
+// `file` is deliberately the same URL as the entry's own
+// `//# sourceURL=`, which is also `sources[last]` (the script's own
+// body). Bundlers avoid that collision — devtools keys files by URL,
+// so a mapped source sharing its generated script's URL could in
+// principle show up twice, or empty. Verified in Chrome's Sources
+// panel that it doesn't: the mapped file shadows the generated one,
+// and a script with one `@require` shows exactly two entries — the
+// `.user.js` and the require nested under a `<host>/<path>` subtree —
+// both with their original text. Keeping the URLs identical is what
+// lets the Log tab's stack-ref linkification match on one string.
+export function buildSourceMap(args) {
+    const sources = args.segments.map((s) => s.url);
+    // generatedLine → {sourceIndex, originalLine}. Later segments win on
+    // overlap, which can't happen for the layouts we generate but keeps
+    // the function total.
+    const perLine = new Map();
+    args.segments.forEach((seg, srcIdx) => {
+        for (let k = 0; k < seg.lineCount; k++) {
+            perLine.set(seg.generatedLine + k, { srcIdx, origLine: k });
+        }
+    });
+    // VLQ fields after the first are deltas against the previous
+    // segment, carried across line groups (only the generated column
+    // resets per line — and ours is always 0, so it never contributes).
+    let prevSrcIdx = 0;
+    let prevOrigLine = 0;
+    const groups = [];
+    for (let gen = 0; gen < args.totalLines; gen++) {
+        const hit = perLine.get(gen);
+        if (!hit) {
+            groups.push('');
+            continue;
+        }
+        groups.push(encodeVlq(0) +
+            encodeVlq(hit.srcIdx - prevSrcIdx) +
+            encodeVlq(hit.origLine - prevOrigLine) +
+            encodeVlq(0));
+        prevSrcIdx = hit.srcIdx;
+        prevOrigLine = hit.origLine;
+    }
+    return {
+        version: 3,
+        file: args.file,
+        sources,
+        sourcesContent: args.segments.map((seg) => seg.content),
+        names: [],
+        mappings: groups.join(';'),
+    };
+}
+// Look up the original file + line for a 1-based generated line.
+// Returns null for lines no segment covers. In 1-based terms those are
+// line 1 (the wrap head), each `// @require` marker line, each `;` ASI
+// guard between requires, and the closing `});`. They are ours, not
+// the user's, so leaving them unmapped is correct — the caller drops
+// the link rather than pointing at a neighbouring line.
+export function lookupGeneratedLine(segments, generatedLine) {
+    const gen0 = generatedLine - 1;
+    for (const seg of segments) {
+        if (gen0 >= seg.generatedLine && gen0 < seg.generatedLine + seg.lineCount) {
+            return { url: seg.url, line: gen0 - seg.generatedLine + 1 };
+        }
+    }
+    return null;
+}
+// Rewrite a stack ref that points into the concatenated entry so it
+// names the original `@require` (or the body) at its own line.
+//
+// Every frame from the combined entry carries `entryUrl` — the
+// script's own `//# sourceURL=`, which V8 stamps on the whole entry
+// regardless of which concatenated file the code came from. So the
+// URL match is the test for "is this frame ours to remap"; refs to
+// anything else (the page, another userscript, `__prelude.js`) pass
+// through untouched.
+//
+// Columns pass through unchanged, and that is exact rather than
+// approximate: composition only ever moves whole lines, never code
+// within a line. A script with NO requires has no segments at all, so
+// it returns early — see the layout notes in composed-source.ts for
+// the column caveat that applies to that case.
+export function remapStackRef(ref, entryUrl, segments) {
+    if (segments.length === 0)
+        return null;
+    if (ref.url !== entryUrl)
+        return null;
+    const orig = lookupGeneratedLine(segments, ref.line);
+    if (!orig)
+        return null;
+    return { url: orig.url, line: orig.line, col: ref.col };
+}
+// UTF-8 → base64. `btoa` alone throws on any code point above U+00FF,
+// and userscripts are full of them (the script that prompted Mode A is
+// half Chinese). Encode to bytes first, then base64 the byte string.
+function base64Utf8(text) {
+    const bytes = new TextEncoder().encode(text);
+    let binary = '';
+    // Chunked so a large source doesn't blow the argument limit on
+    // String.fromCharCode.apply.
+    const CHUNK = 0x8000;
+    for (let i = 0; i < bytes.length; i += CHUNK) {
+        binary += String.fromCharCode(...bytes.subarray(i, i + CHUNK));
+    }
+    return btoa(binary);
+}
+// The `//# sourceMappingURL=` line to append to the generated entry.
+// Inline data URI because a `sourcemonkey://` map URL would be no more
+// fetchable than the sources themselves.
+export function inlineSourceMapComment(map) {
+    return `//# sourceMappingURL=data:application/json;charset=utf-8;base64,${base64Utf8(JSON.stringify(map))}`;
+}

package/lib/stack-link.d.ts

@@ -0,0 +1,15 @@
+import type { StackLayout } from './composed-source.js';
+export type RefRun = {
+    kind: 'text';
+    text: string;
+} | {
+    kind: 'ref';
+    text: string;
+    url: string;
+    line: number;
+    col: number;
+};
+export declare function parseStackRefs(text: string): RefRun[];
+export declare function displayRefText(text: string, url: string): string;
+export declare function remapStackText(text: string, layouts: Iterable<StackLayout>): string;
+export declare const WRAPPER_FILE = "__wrapper.js";