ushman-characterize 0.4.0

package/dist/cli/parse-flags.js

@@ -0,0 +1,60 @@
+export const parseKeyValueFlags = (args, options = {}) => {
+    const positionals = [];
+    const flags = new Map();
+    const booleanFlags = new Set(options.booleanFlags ?? []);
+    const stringFlags = new Set(options.stringFlags ?? []);
+    const knownFlags = new Set([...booleanFlags, ...stringFlags]);
+    const parseInlineFlag = (arg) => {
+        if (!arg.startsWith('--') || !arg.includes('=')) {
+            return null;
+        }
+        const [key, ...rest] = arg.slice(2).split('=');
+        if (!key) {
+            throw new Error(`Unknown flag: ${arg}`);
+        }
+        return {
+            key,
+            value: rest.join('='),
+        };
+    };
+    const ensureKnownFlag = (key, rawArg) => {
+        if (!knownFlags.has(key)) {
+            throw new Error(`Unknown flag: ${rawArg}`);
+        }
+    };
+    const consumeSeparateValue = (key, index) => {
+        const next = args[index + 1];
+        if (!next || next.startsWith('-')) {
+            throw new Error(`Missing value for --${key}`);
+        }
+        return next;
+    };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (!arg.startsWith('-')) {
+            positionals.push(arg);
+            continue;
+        }
+        const inlineFlag = parseInlineFlag(arg);
+        if (inlineFlag) {
+            ensureKnownFlag(inlineFlag.key, arg);
+            if (booleanFlags.has(inlineFlag.key)) {
+                throw new Error(`Flag does not take a value: --${inlineFlag.key}`);
+            }
+            if (inlineFlag.value.length === 0) {
+                throw new Error(`Missing value for --${inlineFlag.key}`);
+            }
+            flags.set(inlineFlag.key, inlineFlag.value);
+            continue;
+        }
+        const key = arg.replace(/^-{1,2}/u, '');
+        ensureKnownFlag(key, arg);
+        if (booleanFlags.has(key)) {
+            flags.set(key, true);
+            continue;
+        }
+        flags.set(key, consumeSeparateValue(key, index));
+        index += 1;
+    }
+    return { flags, positionals };
+};

package/dist/cli.d.ts

@@ -0,0 +1,39 @@
+import { type Logger } from './cli/logger.ts';
+/**
+ * Programmatic entry point for seed-time pure scaffold population and the legacy manual
+ * `stub-pure --bundle=...` flow.
+ */
+export declare const runStubPureCommand: ({ bundlePath, log, regenStale, workspaceRoot, }: {
+    readonly bundlePath?: string;
+    readonly log: Logger;
+    readonly regenStale?: boolean;
+    readonly workspaceRoot: string;
+}) => Promise<import("./stub-pure.ts").PopulateScaffoldsResult | {
+    autoAssertionCount: number;
+    pureFunctionCount: number;
+    stubCount: number;
+    totalTopLevelFunctions: number;
+    written: string[];
+} | {
+    sidecarPath: string;
+    skipped: string[];
+    toolingGaps: string[];
+    written: string[];
+}>;
+/**
+ * Programmatic entry point for seed-time smoke scaffold population and the legacy manual
+ * `stub-states` screenshot scaffold flow.
+ */
+export declare const runStubStatesCommand: ({ log, regenStale, workspaceRoot, }: {
+    readonly log: Logger;
+    readonly regenStale?: boolean;
+    readonly workspaceRoot: string;
+}) => Promise<import("./scene.ts").PopulateSmokeScaffoldsResult | {
+    stale: string[];
+    written: string[];
+}>;
+/**
+ * Run the standalone characterize CLI.
+ */
+export declare const runCharacterizeCommand: (args: readonly string[]) => Promise<number>;
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAGA,OAAO,EAAuB,KAAK,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAsLnE;;;GAGG;AACH,eAAO,MAAM,kBAAkB,GAAU,iDAKtC;IACC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAClC;;;;;;;;aA7CkB,MAAM,EAAE;;aAER,MAAM,EAAE;EA4F1B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,oBAAoB,GAAU,qCAIxC;IACC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAClC;;;EA2CA,CAAC;AAuMF;;GAEG;AACH,eAAO,MAAM,sBAAsB,GAAU,MAAM,SAAS,MAAM,EAAE,KAAG,OAAO,CAAC,MAAM,CA2BpF,CAAC"}

package/dist/cli.js

@@ -0,0 +1,439 @@
+import { mkdir } from 'node:fs/promises';
+import path from 'node:path';
+import { captureCharacterization } from "./capture.js";
+import { createConsoleLogger } from "./cli/logger.js";
+import { parseKeyValueFlags } from "./cli/parse-flags.js";
+import { generateReplayCharacterization } from "./generate-replay.js";
+import { instrumentBundle } from "./instrument.js";
+import { recordCharacterizeToolingGap, recordCharacterizeValidatorResult } from "./ledger.js";
+import { parseRebindMapping, rewriteReplayImports } from "./rebind.js";
+import { createVerifyReport } from "./replay-report.js";
+import { populateSmokeScaffolds, scaffoldSceneCharacterizationTests } from "./scene.js";
+import { SEED_FINGERPRINT_SIDECAR_RELATIVE_PATH } from "./seed-scaffolds.js";
+import { populateScaffolds, scaffoldPureCharacterizationTests } from "./stub-pure.js";
+import { workspaceHarnessPaths } from "./trace-format.js";
+import { assertV4Workspace, withPipelineLock } from "./workspace-paths.js";
+const HELP_TEXT = `Usage: ushman-characterize <subcommand> [workspace] [options]
+
+Subcommands:
+  stub-pure         Generate pure-function characterization tests.
+  stub-states       Generate scene characterization tests from screenshot baselines.
+  instrument        Write an instrumented bundle to disk.
+  capture           Capture live traces from a workspace stage.
+  generate-replay   Generate replay fixtures and Bun tests from captured traces.
+  replay            Run generated replay tests in strict or lenient mode.
+  rebind            Rewrite generated replay imports to extracted source files.
+
+Examples:
+  ushman-characterize stub-pure . --bundle=public/assets/index.js
+  ushman-characterize stub-pure . --regen-stale
+  ushman-characterize stub-states . --regen-stale
+  ushman-characterize capture . --bundle=public/assets/index.js --states=lobby --mode=preview
+  ushman-characterize instrument --bundle=public/assets/index.js --output=public/assets/index.instrumented.js --source-map=external
+  ushman-characterize rebind . --map='.lab/characterize/modules/CameraController.mjs:CameraController=src/camera/CameraController.js' --dry-run
+
+Defaults:
+  capture --mode=preview
+  capture --capture-side-effects=false
+  generate-replay --max-cases=10
+  instrument --source-map=external
+
+Notes:
+  capture, rebind, and scaffold population emit characterize validator-result ledger entries
+`;
+const VALID_SOURCE_MAP_MODES = ['external', 'inline', 'off'];
+const parseStateList = (raw) => (raw ?? '')
+    .split(',')
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+const resolveFromWorkspace = (workspaceRoot, value) => path.isAbsolute(value) ? value : path.join(workspaceRoot, value);
+const parseWorkspaceRoot = (positionals) => path.resolve(positionals[0] ?? process.cwd());
+const resolveSourceMapMode = (value) => {
+    if (value === undefined) {
+        return 'external';
+    }
+    if (VALID_SOURCE_MAP_MODES.includes(value)) {
+        return value;
+    }
+    throw new Error(`Invalid --source-map="${value}". Use: ${VALID_SOURCE_MAP_MODES.join(', ')}.`);
+};
+const renderRebindPreview = ({ after, before, filePath, }) => `${filePath}
+--- before
+${before}
++++ after
+${after}`;
+const parseRebindMappings = (args) => {
+    const mappings = new Map();
+    for (let index = 0; index < args.length; index += 1) {
+        const value = args[index];
+        if (!value) {
+            continue;
+        }
+        if (value === '--map') {
+            const pair = args[index + 1];
+            if (!pair || pair.startsWith('-')) {
+                throw new Error('Missing value for --map');
+            }
+            index += 1;
+            const mapping = parseRebindMapping(pair);
+            mappings.set(mapping.selector, mapping.target);
+            continue;
+        }
+        if (value.startsWith('--map=')) {
+            const mapping = parseRebindMapping(value.slice('--map='.length));
+            mappings.set(mapping.selector, mapping.target);
+        }
+    }
+    return mappings;
+};
+const resolveReplayMode = ({ lenient, mode, strict, }) => {
+    const explicitModes = [strict, lenient, mode !== undefined].filter(Boolean).length;
+    if (strict && lenient) {
+        throw new Error('Choose either --strict or --lenient, not both.');
+    }
+    if (explicitModes > 1 && mode !== undefined) {
+        throw new Error('Use either --mode=<strict|lenient> or the boolean mode flags, not both.');
+    }
+    if (strict) {
+        return 'strict';
+    }
+    if (lenient) {
+        return 'lenient';
+    }
+    if (mode === undefined) {
+        return 'strict';
+    }
+    if (mode !== 'lenient' && mode !== 'strict') {
+        throw new Error(`Unsupported replay mode "${mode}". Use strict or lenient.`);
+    }
+    return mode;
+};
+const buildPopulateFailureResult = ({ summary, workspaceRoot, }) => ({
+    sidecarPath: path.join(workspaceRoot, SEED_FINGERPRINT_SIDECAR_RELATIVE_PATH),
+    skipped: [],
+    toolingGaps: [summary],
+    written: [],
+});
+const handlePopulateCommandFailure = async ({ error, log, subcommand, workspaceRoot, }) => {
+    const message = error instanceof Error ? error.message : String(error);
+    const summary = `${subcommand} population failed: ${message}`;
+    await recordCharacterizeToolingGap({
+        body: `${summary}\nSeed should continue, but this workspace needs manual follow-up before characterize scaffolds can be trusted.`,
+        summary,
+        workspaceRoot,
+    });
+    await recordCharacterizeValidatorResult({
+        summary,
+        verdict: 'yellow',
+        workspaceRoot,
+    });
+    log.warn(summary);
+};
+/**
+ * Programmatic entry point for seed-time pure scaffold population and the legacy manual
+ * `stub-pure --bundle=...` flow.
+ */
+export const runStubPureCommand = async ({ bundlePath, log, regenStale = false, workspaceRoot, }) => {
+    if (regenStale) {
+        try {
+            const result = await withPipelineLock({
+                command: 'ushman-characterize stub-pure --regen-stale',
+                work: async () => populateScaffolds({
+                    workspaceDir: workspaceRoot,
+                }),
+                workspaceRoot,
+            });
+            log.info(`populated ${result.written.length} pure scaffold file(s)`);
+            for (const gap of result.toolingGaps) {
+                log.warn(gap);
+            }
+            return result;
+        }
+        catch (error) {
+            if (typeof error.exitCode === 'number') {
+                throw error;
+            }
+            await handlePopulateCommandFailure({
+                error,
+                log,
+                subcommand: 'stub-pure',
+                workspaceRoot,
+            });
+            return buildPopulateFailureResult({
+                summary: `stub-pure population failed: ${error instanceof Error ? error.message : String(error)}`,
+                workspaceRoot,
+            });
+        }
+    }
+    if (!bundlePath) {
+        throw new Error('stub-pure requires --bundle=<path>.');
+    }
+    const result = await withPipelineLock({
+        command: 'ushman-characterize stub-pure',
+        work: async () => scaffoldPureCharacterizationTests({
+            bundlePath: resolveFromWorkspace(workspaceRoot, bundlePath),
+            workspaceRoot,
+        }),
+        workspaceRoot,
+    });
+    log.info(`classified ${result.pureFunctionCount} pure function(s) from ${result.totalTopLevelFunctions} top-level callables; ${result.autoAssertionCount} auto assertion(s) generated`);
+    return result;
+};
+/**
+ * Programmatic entry point for seed-time smoke scaffold population and the legacy manual
+ * `stub-states` screenshot scaffold flow.
+ */
+export const runStubStatesCommand = async ({ log, regenStale = false, workspaceRoot, }) => {
+    if (regenStale) {
+        try {
+            const result = await withPipelineLock({
+                command: 'ushman-characterize stub-states --regen-stale',
+                work: async () => populateSmokeScaffolds({
+                    workspaceDir: workspaceRoot,
+                }),
+                workspaceRoot,
+            });
+            log.info(`populated ${result.written.length} smoke scaffold file(s)`);
+            for (const gap of result.toolingGaps) {
+                log.warn(gap);
+            }
+            return result;
+        }
+        catch (error) {
+            if (typeof error.exitCode === 'number') {
+                throw error;
+            }
+            await handlePopulateCommandFailure({
+                error,
+                log,
+                subcommand: 'stub-states',
+                workspaceRoot,
+            });
+            return buildPopulateFailureResult({
+                summary: `stub-states population failed: ${error instanceof Error ? error.message : String(error)}`,
+                workspaceRoot,
+            });
+        }
+    }
+    const result = await withPipelineLock({
+        command: 'ushman-characterize stub-states',
+        work: async () => scaffoldSceneCharacterizationTests({
+            workspaceRoot,
+        }),
+        workspaceRoot,
+    });
+    log.info(`scaffolded ${result.written.length} scene characterization test file(s)`);
+    return result;
+};
+const handleStubPure = async ({ log, rest }) => {
+    const { flags, positionals } = parseKeyValueFlags(rest, {
+        booleanFlags: ['regen-stale'],
+        stringFlags: ['bundle'],
+    });
+    const workspaceRoot = parseWorkspaceRoot(positionals);
+    await runStubPureCommand({
+        bundlePath: flags.get('bundle'),
+        log,
+        regenStale: flags.get('regen-stale') === true,
+        workspaceRoot,
+    });
+    return 0;
+};
+const handleStubStates = async ({ log, rest }) => {
+    const { flags, positionals } = parseKeyValueFlags(rest, {
+        booleanFlags: ['regen-stale'],
+    });
+    const workspaceRoot = parseWorkspaceRoot(positionals);
+    await runStubStatesCommand({
+        log,
+        regenStale: flags.get('regen-stale') === true,
+        workspaceRoot,
+    });
+    return 0;
+};
+const handleInstrument = async ({ log, rest }) => {
+    const { flags } = parseKeyValueFlags(rest, {
+        stringFlags: ['bundle', 'output', 'source-map'],
+    });
+    const bundlePath = flags.get('bundle');
+    const outputPath = flags.get('output');
+    if (!bundlePath || !outputPath) {
+        throw new Error('instrument requires --bundle=<path> and --output=<path>.');
+    }
+    const sourceMapMode = resolveSourceMapMode(flags.get('source-map'));
+    const result = await instrumentBundle({
+        bundlePath: path.resolve(bundlePath),
+        outputPath: path.resolve(outputPath),
+        sourceMapMode,
+    });
+    log.info(`instrumented ${result.instrumentedSymbols.length} callable(s) -> ${result.outputPath}${result.mapPath ? ` (+ ${result.mapPath})` : ''}`);
+    return 0;
+};
+const handleCapture = async ({ log, rest }) => {
+    const { flags, positionals } = parseKeyValueFlags(rest, {
+        booleanFlags: ['capture-side-effects', 'scene-only'],
+        stringFlags: ['bundle', 'mode', 'states'],
+    });
+    const workspaceRoot = parseWorkspaceRoot(positionals);
+    const result = await withPipelineLock({
+        command: 'ushman-characterize capture',
+        work: async () => captureCharacterization({
+            bundlePath: flags.get('bundle')
+                ? resolveFromWorkspace(workspaceRoot, flags.get('bundle'))
+                : null,
+            captureSideEffects: flags.get('capture-side-effects') === true,
+            mode: flags.get('mode') ?? 'preview',
+            sceneOnly: flags.get('scene-only') === true,
+            states: parseStateList(flags.get('states')),
+            workspaceRoot,
+        }),
+        workspaceRoot,
+    });
+    for (const state of result.states) {
+        log.info(`state=${state.state} rawCalls=${state.rawCalls} unique=${state.uniqueCalls} dropped=${state.droppedUniqueCalls} bytes=${state.traceBytes} fns=${state.functionCount} merged=${state.mergedExistingRecords}`);
+    }
+    if (result.failures.length > 0) {
+        for (const failure of result.failures) {
+            log.warn(`state=${failure.state} phase=${failure.phase} error=${failure.error}`);
+        }
+        return 2;
+    }
+    return 0;
+};
+const handleGenerateReplay = async ({ log, rest }) => {
+    const { flags, positionals } = parseKeyValueFlags(rest, {
+        stringFlags: ['bundle', 'max-cases'],
+    });
+    const workspaceRoot = parseWorkspaceRoot(positionals);
+    const bundlePath = flags.get('bundle');
+    if (!bundlePath) {
+        throw new Error('generate-replay requires --bundle=<path>.');
+    }
+    const result = await withPipelineLock({
+        command: 'ushman-characterize generate-replay',
+        work: async () => generateReplayCharacterization({
+            bundlePath: resolveFromWorkspace(workspaceRoot, bundlePath),
+            maxCases: Number.parseInt(flags.get('max-cases') ?? '10', 10),
+            workspaceRoot,
+        }),
+        workspaceRoot,
+    });
+    log.info(`generated ${result.writtenTests.length} replay test file(s) and ${result.writtenFixtures.length} fixture file(s)`);
+    if (result.skippedFunctions.length > 0) {
+        for (const skipped of result.skippedFunctions) {
+            log.warn(`skipped replay generation for ${skipped.functionName}: ${skipped.reason}`);
+        }
+    }
+    return 0;
+};
+const handleReplay = async ({ log, rest }) => {
+    const { flags, positionals } = parseKeyValueFlags(rest, {
+        booleanFlags: ['lenient', 'strict'],
+        stringFlags: ['filter', 'mode'],
+    });
+    const workspaceRoot = parseWorkspaceRoot(positionals);
+    await assertV4Workspace(workspaceRoot);
+    const mode = resolveReplayMode({
+        lenient: flags.get('lenient') === true,
+        mode: flags.get('mode'),
+        strict: flags.get('strict') === true,
+    });
+    const filter = flags.get('filter') ?? null;
+    const cmd = ['bun', 'test', 'tests/replay/*.test.ts'];
+    if (filter) {
+        cmd.push('--filter', filter);
+    }
+    const result = Bun.spawnSync(cmd, {
+        cwd: workspaceRoot,
+        env: {
+            ...process.env,
+            USHMAN_CHARACTERIZE_MATCH_MODE: mode,
+        },
+        stderr: 'inherit',
+        stdout: 'inherit',
+    });
+    const harnessPaths = workspaceHarnessPaths(workspaceRoot);
+    await mkdir(harnessPaths.reportsDir, { recursive: true });
+    const report = createVerifyReport({
+        exitCode: result.exitCode,
+        filter,
+        mode,
+        workspaceRoot,
+    });
+    const reportPath = path.join(harnessPaths.reportsDir, 'verify-report.json');
+    await Bun.write(reportPath, `${JSON.stringify(report, null, 2)}\n`);
+    log.info(`wrote replay report to ${reportPath}`);
+    return result.exitCode;
+};
+const handleRebind = async ({ log, rest }) => {
+    const { flags, positionals } = parseKeyValueFlags(rest, {
+        booleanFlags: ['dry-run', 'yes'],
+        stringFlags: ['map'],
+    });
+    const workspaceRoot = parseWorkspaceRoot(positionals);
+    const mappings = parseRebindMappings(rest);
+    if (mappings.size === 0) {
+        throw new Error('rebind requires at least one --map=symbol=path entry.');
+    }
+    const dryRun = flags.get('dry-run') === true;
+    const result = await withPipelineLock({
+        command: 'ushman-characterize rebind',
+        disabled: dryRun,
+        work: async () => rewriteReplayImports({
+            dryRun,
+            mappings,
+            workspaceRoot,
+            yes: flags.get('yes') === true,
+        }),
+        workspaceRoot,
+    });
+    if (dryRun) {
+        for (const preview of result.previews) {
+            log.info(renderRebindPreview(preview));
+        }
+    }
+    log.info(`${dryRun ? 'would touch' : 'updated'} ${result.files.length} replay test file(s)`);
+    return 0;
+};
+const COMMAND_HANDLERS = {
+    capture: handleCapture,
+    'generate-replay': handleGenerateReplay,
+    instrument: handleInstrument,
+    rebind: handleRebind,
+    replay: handleReplay,
+    'stub-pure': handleStubPure,
+    'stub-states': handleStubStates,
+};
+/**
+ * Run the standalone characterize CLI.
+ */
+export const runCharacterizeCommand = async (args) => {
+    const log = createConsoleLogger();
+    const [subcommand, ...rest] = args;
+    if (!subcommand || subcommand === '--help' || subcommand === '-h') {
+        process.stdout.write(`${HELP_TEXT}\n`);
+        return subcommand ? 0 : 1;
+    }
+    const handler = COMMAND_HANDLERS[subcommand];
+    if (!handler) {
+        log.error(`Unknown characterize subcommand: ${subcommand}`);
+        process.stdout.write(`${HELP_TEXT}\n`);
+        return 1;
+    }
+    try {
+        return await handler({
+            log,
+            rest,
+        });
+    }
+    catch (error) {
+        log.error(error instanceof Error ? error.message : String(error));
+        return typeof error.exitCode === 'number'
+            ? error.exitCode
+            : 1;
+    }
+};
+if (import.meta.main) {
+    const exitCode = await runCharacterizeCommand(process.argv.slice(2));
+    process.exit(exitCode);
+}

package/dist/constants.d.ts

@@ -0,0 +1,20 @@
+export declare const FLOAT_PRECISION_SCALE = 10000;
+export declare const DEFAULT_TRACE_DEPTH_LIMIT = 8;
+export declare const DEFAULT_TRACE_BYTES_LIMIT: number;
+export declare const DEFAULT_PER_FUNCTION_SHAPE_CAP = 25;
+export declare const DEFAULT_MAX_UNIQUE_RECORDS_PER_STATE = 25000;
+export declare const DEFAULT_CAPTURE_SETTLE_FRAMES = 8;
+export declare const DEFAULT_CAPTURE_VIEWPORT: {
+    readonly height: 720;
+    readonly width: 1280;
+};
+export declare const EXEMPT_FIELD_MARKER = "__ushman_exempt__";
+export declare const CHARACTERIZE_SUPPORT_VERSION = "2";
+export declare const TRACE_RECORD_SCHEMA_NAME = "ushman.characterize.trace-record";
+export declare const TRACE_RECORD_SCHEMA_VERSION = "1";
+export declare const REPLAY_FIXTURE_SCHEMA_NAME = "ushman.characterize.replay-fixture";
+export declare const REPLAY_FIXTURE_SCHEMA_VERSION = "1";
+export declare const TRACE_RUNTIME_VERSION = 2;
+export declare const VERIFY_REPORT_SCHEMA_NAME = "ushman.characterize.verify-report";
+export declare const VERIFY_REPORT_SCHEMA_VERSION = "1";
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qBAAqB,QAAS,CAAC;AAC5C,eAAO,MAAM,yBAAyB,IAAI,CAAC;AAC3C,eAAO,MAAM,yBAAyB,QAAmB,CAAC;AAC1D,eAAO,MAAM,8BAA8B,KAAK,CAAC;AACjD,eAAO,MAAM,oCAAoC,QAAS,CAAC;AAC3D,eAAO,MAAM,6BAA6B,IAAI,CAAC;AAC/C,eAAO,MAAM,wBAAwB;;;CAG3B,CAAC;AACX,eAAO,MAAM,mBAAmB,sBAAsB,CAAC;AACvD,eAAO,MAAM,4BAA4B,MAAM,CAAC;AAChD,eAAO,MAAM,wBAAwB,qCAAqC,CAAC;AAC3E,eAAO,MAAM,2BAA2B,MAAM,CAAC;AAC/C,eAAO,MAAM,0BAA0B,uCAAuC,CAAC;AAC/E,eAAO,MAAM,6BAA6B,MAAM,CAAC;AACjD,eAAO,MAAM,qBAAqB,IAAI,CAAC;AACvC,eAAO,MAAM,yBAAyB,sCAAsC,CAAC;AAC7E,eAAO,MAAM,4BAA4B,MAAM,CAAC"}

package/dist/constants.js

@@ -0,0 +1,19 @@
+export const FLOAT_PRECISION_SCALE = 10_000;
+export const DEFAULT_TRACE_DEPTH_LIMIT = 8;
+export const DEFAULT_TRACE_BYTES_LIMIT = 50 * 1024 * 1024;
+export const DEFAULT_PER_FUNCTION_SHAPE_CAP = 25;
+export const DEFAULT_MAX_UNIQUE_RECORDS_PER_STATE = 25_000;
+export const DEFAULT_CAPTURE_SETTLE_FRAMES = 8;
+export const DEFAULT_CAPTURE_VIEWPORT = {
+    height: 720,
+    width: 1280,
+};
+export const EXEMPT_FIELD_MARKER = '__ushman_exempt__';
+export const CHARACTERIZE_SUPPORT_VERSION = '2';
+export const TRACE_RECORD_SCHEMA_NAME = 'ushman.characterize.trace-record';
+export const TRACE_RECORD_SCHEMA_VERSION = '1';
+export const REPLAY_FIXTURE_SCHEMA_NAME = 'ushman.characterize.replay-fixture';
+export const REPLAY_FIXTURE_SCHEMA_VERSION = '1';
+export const TRACE_RUNTIME_VERSION = 2;
+export const VERIFY_REPORT_SCHEMA_NAME = 'ushman.characterize.verify-report';
+export const VERIFY_REPORT_SCHEMA_VERSION = '1';

package/dist/dedupe-contract.d.ts

@@ -0,0 +1,26 @@
+type TraceDedupeRecord = {
+    readonly args: unknown;
+    readonly bindingName: string;
+    readonly className: null | string;
+    readonly expected: unknown;
+    readonly functionName: string;
+    readonly memberKind: 'function' | 'method';
+    readonly methodName: null | string;
+    readonly sideEffects: readonly unknown[];
+    readonly thisArg: unknown;
+    readonly threw: unknown;
+};
+export declare const toTraceDeduplicationPayload: (record: TraceDedupeRecord) => {
+    args: unknown;
+    bindingName: string;
+    className: string | null;
+    expected: unknown;
+    functionName: string;
+    memberKind: "function" | "method";
+    methodName: string | null;
+    sideEffects: readonly unknown[];
+    thisArg: unknown;
+    threw: unknown;
+};
+export {};
+//# sourceMappingURL=dedupe-contract.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dedupe-contract.d.ts","sourceRoot":"","sources":["../src/dedupe-contract.ts"],"names":[],"mappings":"AAAA,KAAK,iBAAiB,GAAG;IACrB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,IAAI,GAAG,MAAM,CAAC;IAClC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,UAAU,EAAE,UAAU,GAAG,QAAQ,CAAC;IAC3C,QAAQ,CAAC,UAAU,EAAE,IAAI,GAAG,MAAM,CAAC;IACnC,QAAQ,CAAC,WAAW,EAAE,SAAS,OAAO,EAAE,CAAC;IACzC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CAC3B,CAAC;AAEF,eAAO,MAAM,2BAA2B,GAAI,QAAQ,iBAAiB;;;;;;;;;;;CAWnE,CAAC"}

package/dist/dedupe-contract.js

@@ -0,0 +1,12 @@
+export const toTraceDeduplicationPayload = (record) => ({
+    args: record.args,
+    bindingName: record.bindingName,
+    className: record.className,
+    expected: record.expected,
+    functionName: record.functionName,
+    memberKind: record.memberKind,
+    methodName: record.methodName,
+    sideEffects: record.sideEffects,
+    thisArg: record.thisArg,
+    threw: record.threw,
+});

package/dist/default-export.d.ts

@@ -0,0 +1,6 @@
+import * as t from '@babel/types';
+export declare const isAnonymousDefaultExportCallableStatement: (statement: t.Statement | t.ModuleDeclaration) => boolean;
+export declare const collectTopLevelBindingNames: (statements: readonly (t.Statement | t.ModuleDeclaration)[]) => Set<string>;
+export declare const resolveAnonymousDefaultExportBindingName: (takenNames: ReadonlySet<string>) => string;
+export declare const getAnonymousDefaultExportBindingName: (statements: readonly (t.Statement | t.ModuleDeclaration)[]) => string | null;
+//# sourceMappingURL=default-export.d.ts.map

package/dist/default-export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-export.d.ts","sourceRoot":"","sources":["../src/default-export.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAmBlC,eAAO,MAAM,yCAAyC,GAAI,WAAW,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC,iBAAiB,YAI3C,CAAC;AAE5D,eAAO,MAAM,2BAA2B,GAAI,YAAY,SAAS,CAAC,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC,iBAAiB,CAAC,EAAE,gBA0BrG,CAAC;AAEF,eAAO,MAAM,wCAAwC,GAAI,YAAY,WAAW,CAAC,MAAM,CAAC,WAUvF,CAAC;AAEF,eAAO,MAAM,oCAAoC,GAAI,YAAY,SAAS,CAAC,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC,iBAAiB,CAAC,EAAE,kBAM9G,CAAC"}