ushman-characterize 0.4.0

package/dist/default-export.js

@@ -0,0 +1,52 @@
+import * as t from '@babel/types';
+const DEFAULT_EXPORT_BINDING_BASENAME = 'defaultExport';
+const addBindingIdentifiers = ({ names, value, }) => {
+    if (!value) {
+        return;
+    }
+    for (const name of Object.keys(t.getBindingIdentifiers(value))) {
+        names.add(name);
+    }
+};
+export const isAnonymousDefaultExportCallableStatement = (statement) => t.isExportDefaultDeclaration(statement) &&
+    ((t.isFunctionDeclaration(statement.declaration) && !statement.declaration.id) ||
+        t.isFunctionExpression(statement.declaration) ||
+        t.isArrowFunctionExpression(statement.declaration));
+export const collectTopLevelBindingNames = (statements) => {
+    const names = new Set();
+    for (const statement of statements) {
+        if (t.isImportDeclaration(statement)) {
+            for (const specifier of statement.specifiers) {
+                names.add(specifier.local.name);
+            }
+            continue;
+        }
+        if (t.isExportNamedDeclaration(statement) || t.isExportDefaultDeclaration(statement)) {
+            addBindingIdentifiers({
+                names,
+                value: statement.declaration,
+            });
+            continue;
+        }
+        addBindingIdentifiers({
+            names,
+            value: statement,
+        });
+    }
+    return names;
+};
+export const resolveAnonymousDefaultExportBindingName = (takenNames) => {
+    let candidate = DEFAULT_EXPORT_BINDING_BASENAME;
+    let suffix = 2;
+    while (takenNames.has(candidate)) {
+        candidate = `${DEFAULT_EXPORT_BINDING_BASENAME}_${suffix}`;
+        suffix += 1;
+    }
+    return candidate;
+};
+export const getAnonymousDefaultExportBindingName = (statements) => {
+    if (!statements.some((statement) => isAnonymousDefaultExportCallableStatement(statement))) {
+        return null;
+    }
+    return resolveAnonymousDefaultExportBindingName(collectTopLevelBindingNames(statements));
+};

package/dist/format-contract.d.ts

@@ -0,0 +1,25 @@
+type VersionedEnvelope = {
+    readonly schemaName: string;
+    readonly schemaVersion: string;
+    readonly supportVersion: string;
+};
+export type ReplayFixtureDocument<TCase> = VersionedEnvelope & {
+    readonly cases: readonly TCase[];
+};
+export declare const stampTraceRecord: <TValue extends Record<string, unknown>>(value: TValue) => TValue & {
+    schemaName: string;
+    schemaVersion: string;
+    supportVersion: string;
+};
+export declare const parseTraceRecord: <TValue extends Record<string, unknown>>({ context, value, }: {
+    readonly context: string;
+    readonly value: unknown;
+}) => TValue;
+export declare const createReplayFixtureDocument: <TCase>(cases: readonly TCase[]) => ReplayFixtureDocument<TCase>;
+export declare const parseReplayFixtureDocument: <TCase>({ caseValidator, context, value, }: {
+    readonly caseValidator: (value: unknown) => value is TCase;
+    readonly context: string;
+    readonly value: unknown;
+}) => readonly TCase[];
+export {};
+//# sourceMappingURL=format-contract.d.ts.map

package/dist/format-contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-contract.d.ts","sourceRoot":"","sources":["../src/format-contract.ts"],"names":[],"mappings":"AAQA,KAAK,iBAAiB,GAAG;IACrB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACnC,CAAC;AAEF,MAAM,MAAM,qBAAqB,CAAC,KAAK,IAAI,iBAAiB,GAAG;IAC3D,QAAQ,CAAC,KAAK,EAAE,SAAS,KAAK,EAAE,CAAC;CACpC,CAAC;AAqEF,eAAO,MAAM,gBAAgB,GAAI,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,MAAM;;;;CAKpF,CAAC;AAEH,eAAO,MAAM,gBAAgB,GAAI,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,qBAGtE;IACC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CAC3B,KAkBqB,MACrB,CAAC;AAEF,eAAO,MAAM,2BAA2B,GAAI,KAAK,EAAE,OAAO,SAAS,KAAK,EAAE,KAAG,qBAAqB,CAAC,KAAK,CAKtG,CAAC;AAEH,eAAO,MAAM,0BAA0B,GAAI,KAAK,EAAE,oCAI/C;IACC,QAAQ,CAAC,aAAa,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,KAAK,IAAI,KAAK,CAAC;IAC3D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CAC3B,KAwBmB,SAAS,KAAK,EACjC,CAAC"}

package/dist/format-contract.js

@@ -0,0 +1,96 @@
+import { CHARACTERIZE_SUPPORT_VERSION, REPLAY_FIXTURE_SCHEMA_NAME, REPLAY_FIXTURE_SCHEMA_VERSION, TRACE_RECORD_SCHEMA_NAME, TRACE_RECORD_SCHEMA_VERSION, } from "./constants.js";
+const isRecord = (value) => typeof value === 'object' && value !== null;
+const isNullableString = (value) => value === null || typeof value === 'string';
+const isTraceMemberKind = (value) => value === 'function' || value === 'method';
+const describeObservedVersion = (value) => {
+    if (!isRecord(value)) {
+        return 'an invalid non-object payload';
+    }
+    const schemaName = typeof value.schemaName === 'string' ? value.schemaName : 'unknown-schema';
+    const schemaVersion = typeof value.schemaVersion === 'string' ? value.schemaVersion : 'unknown-version';
+    const supportVersion = typeof value.supportVersion === 'string' ? value.supportVersion : 'unknown-support';
+    return `${schemaName}@${schemaVersion} support=${supportVersion}`;
+};
+const assertVersionedEnvelope = ({ context, expected, hint, value, }) => {
+    if (!isRecord(value)) {
+        throw new Error(`${context} must be an object. ${hint}`);
+    }
+    if (value.schemaName !== expected.schemaName ||
+        value.schemaVersion !== expected.schemaVersion ||
+        value.supportVersion !== expected.supportVersion) {
+        throw new Error(`${context} is incompatible. Expected ${expected.schemaName}@${expected.schemaVersion} support=${expected.supportVersion}, found ${describeObservedVersion(value)}. ${hint}`);
+    }
+};
+const stripEnvelope = (value) => {
+    const { schemaName: _schemaName, schemaVersion: _schemaVersion, supportVersion: _supportVersion, ...rest } = value;
+    return rest;
+};
+const assertTraceRecordPayload = ({ context, value }) => {
+    if (!isRecord(value)) {
+        throw new Error(`${context} must be an object. Re-run ushman-characterize capture, then regenerate replay fixtures if needed.`);
+    }
+    if (typeof value.bindingName !== 'string' ||
+        !isNullableString(value.className) ||
+        typeof value.count !== 'number' ||
+        typeof value.functionName !== 'string' ||
+        !isTraceMemberKind(value.memberKind) ||
+        !isNullableString(value.methodName) ||
+        !Array.isArray(value.sideEffects) ||
+        typeof value.state !== 'string') {
+        throw new Error(`${context} has an invalid trace payload shape. Re-run ushman-characterize capture, then regenerate replay fixtures if needed.`);
+    }
+};
+export const stampTraceRecord = (value) => ({
+    ...value,
+    schemaName: TRACE_RECORD_SCHEMA_NAME,
+    schemaVersion: TRACE_RECORD_SCHEMA_VERSION,
+    supportVersion: CHARACTERIZE_SUPPORT_VERSION,
+});
+export const parseTraceRecord = ({ context, value, }) => {
+    assertVersionedEnvelope({
+        context,
+        expected: {
+            schemaName: TRACE_RECORD_SCHEMA_NAME,
+            schemaVersion: TRACE_RECORD_SCHEMA_VERSION,
+            supportVersion: CHARACTERIZE_SUPPORT_VERSION,
+        },
+        hint: 'Re-run ushman-characterize capture, then regenerate replay fixtures if needed.',
+        value,
+    });
+    const payload = stripEnvelope(value);
+    // Envelope validation guards the schema contract; payload validation makes
+    // corrupted trace rows fail early with a trace-specific diagnostic.
+    assertTraceRecordPayload({
+        context,
+        value: payload,
+    });
+    return payload;
+};
+export const createReplayFixtureDocument = (cases) => ({
+    cases,
+    schemaName: REPLAY_FIXTURE_SCHEMA_NAME,
+    schemaVersion: REPLAY_FIXTURE_SCHEMA_VERSION,
+    supportVersion: CHARACTERIZE_SUPPORT_VERSION,
+});
+export const parseReplayFixtureDocument = ({ caseValidator, context, value, }) => {
+    assertVersionedEnvelope({
+        context,
+        expected: {
+            schemaName: REPLAY_FIXTURE_SCHEMA_NAME,
+            schemaVersion: REPLAY_FIXTURE_SCHEMA_VERSION,
+            supportVersion: CHARACTERIZE_SUPPORT_VERSION,
+        },
+        hint: 'Re-run ushman-characterize generate-replay for this workspace.',
+        value,
+    });
+    if (!Array.isArray(value.cases)) {
+        throw new Error(`${context} is missing its cases array. Re-run ushman-characterize generate-replay for this workspace.`);
+    }
+    const cases = value.cases;
+    for (const [index, caseValue] of cases.entries()) {
+        if (!caseValidator(caseValue)) {
+            throw new Error(`${context} has an invalid replay case at index ${index}. Re-run ushman-characterize generate-replay for this workspace.`);
+        }
+    }
+    return cases;
+};

package/dist/function-utils.d.ts

@@ -0,0 +1,6 @@
+import * as t from '@babel/types';
+export declare const isTrivialGetterLike: ({ body, params, }: {
+    readonly body: t.BlockStatement;
+    readonly params: readonly (t.FunctionParameter | t.TSParameterProperty)[];
+}) => boolean;
+//# sourceMappingURL=function-utils.d.ts.map

package/dist/function-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"function-utils.d.ts","sourceRoot":"","sources":["../src/function-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAmBlC,eAAO,MAAM,mBAAmB,GAAI,mBAGjC;IACC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,cAAc,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,iBAAiB,GAAG,CAAC,CAAC,mBAAmB,CAAC,EAAE,CAAC;CAC7E,YAcA,CAAC"}

package/dist/function-utils.js

@@ -0,0 +1,22 @@
+import * as t from '@babel/types';
+const returnsFirstParameter = ({ argument, params, }) => {
+    const firstParameter = params[0];
+    return t.isIdentifier(argument) && t.isIdentifier(firstParameter) && argument.name === firstParameter.name;
+};
+const returnsThisProperty = (argument) => t.isMemberExpression(argument) &&
+    !argument.computed &&
+    t.isThisExpression(argument.object) &&
+    t.isIdentifier(argument.property);
+export const isTrivialGetterLike = ({ body, params, }) => {
+    if (body.body.length !== 1) {
+        return false;
+    }
+    const [statement] = body.body;
+    if (!statement || !t.isReturnStatement(statement) || !statement.argument || !t.isExpression(statement.argument)) {
+        return false;
+    }
+    return (returnsFirstParameter({
+        argument: statement.argument,
+        params,
+    }) || returnsThisProperty(statement.argument));
+};

package/dist/generate-replay.d.ts

@@ -0,0 +1,18 @@
+type ReplayGenerationFailure = {
+    readonly functionName: string;
+    readonly reason: string;
+};
+/**
+ * Generate Bun replay tests and fixture files from captured state traces.
+ */
+export declare const generateReplayCharacterization: ({ bundlePath, maxCases, workspaceRoot, }: {
+    readonly bundlePath: string;
+    readonly maxCases?: number;
+    readonly workspaceRoot: string;
+}) => Promise<{
+    skippedFunctions: ReplayGenerationFailure[];
+    writtenFixtures: string[];
+    writtenTests: string[];
+}>;
+export {};
+//# sourceMappingURL=generate-replay.d.ts.map

package/dist/generate-replay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-replay.d.ts","sourceRoot":"","sources":["../src/generate-replay.ts"],"names":[],"mappings":"AAiDA,KAAK,uBAAuB,GAAG;IAC3B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CAC3B,CAAC;AAyGF;;GAEG;AACH,eAAO,MAAM,8BAA8B,GAAU,0CAIlD;IACC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAClC;;;;EAuFA,CAAC"}

package/dist/generate-replay.js

@@ -0,0 +1,158 @@
+import { mkdir, readdir } from 'node:fs/promises';
+import path from 'node:path';
+import { createReplayFixtureDocument, parseTraceRecord } from "./format-contract.js";
+import { buildStandaloneSymbolModule, parseBundleAst, parseJsonLines, relativeImportPath, sanitizeSymbolName, } from "./shared.js";
+import { canonicalizeTraceValue, ensureWorkspaceTraceHarness, workspaceHarnessPaths } from "./trace-format.js";
+import { assertV4Workspace } from "./workspace-paths.js";
+const readAllTraceFiles = async (workspaceRoot) => {
+    const traceDir = workspaceHarnessPaths(workspaceRoot).tracesDir;
+    const entries = await readdir(traceDir).catch(() => []);
+    const records = [];
+    for (const entry of entries) {
+        if (!entry.endsWith('.jsonl')) {
+            continue;
+        }
+        const filePath = path.join(traceDir, entry);
+        // Keep the zero-based JSONL index so parseTraceRecord can surface a
+        // precise line number when a trace row is version-incompatible or malformed.
+        for (const [index, record] of parseJsonLines(await Bun.file(filePath).text()).entries()) {
+            records.push(parseTraceRecord({
+                context: `Trace record ${entry}:${index + 1}`,
+                value: record,
+            }));
+        }
+    }
+    return records;
+};
+const createReplayFixtures = ({ maxCases, records, }) => records.slice(0, maxCases).map((record, index) => ({
+    args: record.args,
+    expected: record.expected,
+    i: index + 1,
+    sideEffects: canonicalizeTraceValue(record.sideEffects),
+    state: record.state,
+    thisArg: record.thisArg,
+    threw: record.threw,
+}));
+const renderReplayTestSource = ({ fixtureName, harnessFile, importName, memberKind, methodName, modulePath, testFile, }) => {
+    const harnessImport = relativeImportPath({
+        fromFile: testFile,
+        toFile: harnessFile,
+    });
+    const moduleImport = relativeImportPath({
+        fromFile: testFile,
+        toFile: modulePath,
+    });
+    const fixtureImportName = fixtureName.replace(/'/gu, "\\'");
+    const invokeSource = memberKind === 'method' && methodName
+        ? `const instance = replay.hydrate(${importName}, entry.thisArg);
+      return replay.callMethod(instance, '${methodName}', { args: entry.args });`
+        : `return replay.invoke(${importName}, { args: entry.args, thisArg: entry.thisArg });`;
+    return `// AUTO-GENERATED by ushman-characterize generate-replay. Do not hand-edit.
+// generation-version: 1
+import { describe, expect, test } from 'bun:test';
+import { fixture, registerTraceMatchers, replay } from '${harnessImport}';
+import { ${importName} } from '${moduleImport}';
+
+registerTraceMatchers();
+
+const cases = await fixture('replay', '${fixtureImportName}');
+
+describe('${fixtureImportName}', () => {
+  for (const entry of cases) {
+    test(\`replay #\${entry.i} (state=\${entry.state})\`, async () => {
+      const outcome = await replay.capture(async () => {
+        ${invokeSource}
+      });
+
+      expect(outcome.sideEffects).toMatchTrace(entry.sideEffects);
+
+      if (entry.threw !== null) {
+        expect(outcome.threw).not.toBeNull();
+        expect(outcome.threw).toMatchTrace(entry.threw);
+        return;
+      }
+
+      expect(outcome.threw).toBeNull();
+      expect(outcome.value).toMatchTrace(entry.expected);
+    });
+  }
+});
+`;
+};
+const writeStandaloneModule = async ({ bindingName, bundle, modulePath, }) => {
+    await Bun.write(modulePath, `${buildStandaloneSymbolModule({
+        bindingName,
+        bundle,
+        outputFilePath: modulePath,
+    }).trimEnd()}\n`);
+};
+/**
+ * Generate Bun replay tests and fixture files from captured state traces.
+ */
+export const generateReplayCharacterization = async ({ bundlePath, maxCases = 10, workspaceRoot, }) => {
+    await assertV4Workspace(workspaceRoot);
+    const allRecords = await readAllTraceFiles(workspaceRoot);
+    const grouped = new Map();
+    for (const record of allRecords) {
+        const current = grouped.get(record.functionName) ?? [];
+        current.push(record);
+        grouped.set(record.functionName, current);
+    }
+    const bundle = parseBundleAst({
+        source: await Bun.file(bundlePath).text(),
+        sourcePath: bundlePath,
+    });
+    const harnessPaths = await ensureWorkspaceTraceHarness(workspaceRoot);
+    const testsDir = path.join(workspaceRoot, 'tests', 'replay');
+    await mkdir(testsDir, { recursive: true });
+    await mkdir(harnessPaths.replayFixturesDir, { recursive: true });
+    await mkdir(harnessPaths.modulesDir, { recursive: true });
+    const writtenFixtures = [];
+    const writtenTests = [];
+    const skippedFunctions = [];
+    for (const [functionName, records] of [...grouped.entries()].sort((left, right) => left[0].localeCompare(right[0]))) {
+        const sample = records[0];
+        if (!sample) {
+            continue;
+        }
+        const fixtureName = functionName;
+        const safeName = sanitizeSymbolName(functionName);
+        const fixturePath = path.join(harnessPaths.replayFixturesDir, `${safeName}.json`);
+        const modulePath = path.join(harnessPaths.modulesDir, `${safeName}.mjs`);
+        const testFile = path.join(testsDir, `${safeName}.test.ts`);
+        try {
+            await writeStandaloneModule({
+                bindingName: sample.bindingName,
+                bundle,
+                modulePath,
+            });
+        }
+        catch (error) {
+            skippedFunctions.push({
+                functionName,
+                reason: error instanceof Error ? error.message : String(error),
+            });
+            continue;
+        }
+        await Bun.write(fixturePath, `${JSON.stringify(createReplayFixtureDocument(createReplayFixtures({
+            maxCases,
+            records,
+        })), null, 2)}\n`);
+        writtenFixtures.push(fixturePath);
+        await Bun.write(testFile, renderReplayTestSource({
+            fixtureName,
+            harnessFile: harnessPaths.harnessFile,
+            importName: sample.bindingName,
+            memberKind: sample.memberKind,
+            methodName: sample.methodName,
+            modulePath,
+            testFile,
+        }));
+        writtenTests.push(testFile);
+    }
+    return {
+        skippedFunctions,
+        writtenFixtures,
+        writtenTests,
+    };
+};

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { type CaptureCharacterizationOptions, type CaptureCharacterizationResult, type CaptureStateResult, captureCharacterization, readCapturedTraceState, } from './capture.ts';
+export { createConsoleLogger, type Logger } from './cli/logger.ts';
+export { runStubPureCommand, runStubStatesCommand } from './cli.ts';
+export { generateReplayCharacterization } from './generate-replay.ts';
+export { instrumentBundle } from './instrument.ts';
+export { classifyPureTopLevelFunctions } from './purity-classifier.ts';
+export { rewriteReplayImports } from './rebind.ts';
+export { createVerifyReport, type VerifyReport } from './replay-report.ts';
+export { canonicalizeSceneTree, type PopulateSmokeScaffoldsResult, populateSmokeScaffolds, scaffoldSceneCharacterizationTests, } from './scene.ts';
+export { type PopulateScaffoldsResult, populateScaffolds, scaffoldPureCharacterizationTests, } from './stub-pure.ts';
+export { canonicalizeTraceValue as canonicalizeTrace } from './trace-format.ts';
+export type { CaptureServerHost, SceneInspectorDriver } from './types.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,KAAK,8BAA8B,EACnC,KAAK,6BAA6B,EAClC,KAAK,kBAAkB,EACvB,uBAAuB,EACvB,sBAAsB,GACzB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,mBAAmB,EAAE,KAAK,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AACpE,OAAO,EAAE,8BAA8B,EAAE,MAAM,sBAAsB,CAAC;AACtE,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,EAAE,6BAA6B,EAAE,MAAM,wBAAwB,CAAC;AACvE,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,kBAAkB,EAAE,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAC3E,OAAO,EACH,qBAAqB,EACrB,KAAK,4BAA4B,EACjC,sBAAsB,EACtB,kCAAkC,GACrC,MAAM,YAAY,CAAC;AACpB,OAAO,EACH,KAAK,uBAAuB,EAC5B,iBAAiB,EACjB,iCAAiC,GACpC,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,sBAAsB,IAAI,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAChF,YAAY,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,11 @@
+export { captureCharacterization, readCapturedTraceState, } from "./capture.js";
+export { createConsoleLogger } from "./cli/logger.js";
+export { runStubPureCommand, runStubStatesCommand } from "./cli.js";
+export { generateReplayCharacterization } from "./generate-replay.js";
+export { instrumentBundle } from "./instrument.js";
+export { classifyPureTopLevelFunctions } from "./purity-classifier.js";
+export { rewriteReplayImports } from "./rebind.js";
+export { createVerifyReport } from "./replay-report.js";
+export { canonicalizeSceneTree, populateSmokeScaffolds, scaffoldSceneCharacterizationTests, } from "./scene.js";
+export { populateScaffolds, scaffoldPureCharacterizationTests, } from "./stub-pure.js";
+export { canonicalizeTraceValue as canonicalizeTrace } from "./trace-format.js";

package/dist/instrument.d.ts

@@ -0,0 +1,39 @@
+export type InstrumentSourceMapMode = 'external' | 'inline' | 'off';
+type InstrumentSourceMapPayload = {
+    readonly file?: string;
+    readonly mappings: string;
+    readonly names: readonly string[];
+    readonly sourceRoot?: string;
+    readonly sources: readonly string[];
+    readonly sourcesContent?: readonly (null | string)[];
+    readonly version: number;
+};
+type InstrumentBundleSourceResult = {
+    readonly code: string;
+    readonly instrumentedSymbols: readonly string[];
+    readonly map: InstrumentSourceMapPayload | null;
+    readonly skippedSymbols: readonly string[];
+};
+/**
+ * Instrument a bundle source string with the characterization tracer wrappers.
+ */
+export declare const instrumentBundleSource: ({ source, sourceMapFile, sourceMapMode, sourcePath, }: {
+    readonly source: string;
+    readonly sourceMapFile?: string;
+    readonly sourceMapMode?: InstrumentSourceMapMode;
+    readonly sourcePath: string;
+}) => InstrumentBundleSourceResult;
+export declare const instrumentBundle: ({ bundlePath, outputPath, sourceMapMode, }: {
+    readonly bundlePath: string;
+    readonly outputPath: string;
+    readonly sourceMapMode?: InstrumentSourceMapMode;
+}) => Promise<{
+    mapPath: string | null;
+    outputPath: string;
+    code: string;
+    instrumentedSymbols: readonly string[];
+    map: InstrumentSourceMapPayload | null;
+    skippedSymbols: readonly string[];
+}>;
+export {};
+//# sourceMappingURL=instrument.d.ts.map

package/dist/instrument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrument.d.ts","sourceRoot":"","sources":["../src/instrument.ts"],"names":[],"mappings":"AAcA,MAAM,MAAM,uBAAuB,GAAG,UAAU,GAAG,QAAQ,GAAG,KAAK,CAAC;AAEpE,KAAK,0BAA0B,GAAG;IAC9B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,QAAQ,CAAC,cAAc,CAAC,EAAE,SAAS,CAAC,IAAI,GAAG,MAAM,CAAC,EAAE,CAAC;IACrD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,KAAK,4BAA4B,GAAG;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,mBAAmB,EAAE,SAAS,MAAM,EAAE,CAAC;IAChD,QAAQ,CAAC,GAAG,EAAE,0BAA0B,GAAG,IAAI,CAAC;IAChD,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;CAC9C,CAAC;AAkvBF;;GAEG;AACH,eAAO,MAAM,sBAAsB,GAAI,uDAKpC;IACC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,aAAa,CAAC,EAAE,uBAAuB,CAAC;IACjD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC/B,KAAG,4BA+GH,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAU,4CAIpC;IACC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,aAAa,CAAC,EAAE,uBAAuB,CAAC;CACpD;;;UA53BkB,MAAM;yBACS,SAAS,MAAM,EAAE;SACjC,0BAA0B,GAAG,IAAI;oBACtB,SAAS,MAAM,EAAE;EA44B7C,CAAC"}