@stupify/cli 0.0.2 → 0.0.4

package/dist/search-profile.js

@@ -0,0 +1,73 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { defaultChecks, searchChecks } from "./checks.js";
+export async function loadSearchProfile(profilePath) {
+    if (!profilePath)
+        return null;
+    const fullPath = path.resolve(profilePath);
+    const value = JSON.parse(await readFile(fullPath, "utf8"));
+    if (!value || typeof value !== "object" || typeof value.id !== "string" || value.id.length === 0) {
+        throw new Error(`Invalid search profile: ${profilePath}`);
+    }
+    return value;
+}
+export function effectiveSearchChecks(explicitCheckIds, profile) {
+    const checks = explicitCheckIds
+        ? searchChecks(explicitCheckIds)
+        : profilePatternIds(profile).length > 0
+            ? checksById(profilePatternIds(profile))
+            : searchChecks(null);
+    if (!profile?.patterns)
+        return checks;
+    return checks.map((check) => applyPatternOverride(check, profile.patterns?.[check.id]));
+}
+export function effectiveMaxCandidates(defaultValue, profile) {
+    return positiveInteger(profile?.maxCandidates) ?? defaultValue;
+}
+export function effectiveMaxSearchInputTokens(defaultValue, profile) {
+    return positiveInteger(profile?.maxSearchInputTokens) ?? defaultValue;
+}
+export function effectiveRepomixConfig(defaultValue, profile) {
+    const override = profile?.repomix;
+    if (!override)
+        return defaultValue;
+    return {
+        compress: override.compress ?? defaultValue.compress,
+        showLineNumbers: override.showLineNumbers ?? defaultValue.showLineNumbers,
+        removeEmptyLines: override.removeEmptyLines ?? defaultValue.removeEmptyLines,
+        maxFileSizeBytes: positiveInteger(override.maxFileBytes) ?? defaultValue.maxFileSizeBytes,
+        maxTotalSizeBytes: positiveInteger(override.maxTotalBytes) ?? defaultValue.maxTotalSizeBytes,
+        ignorePatterns: override.ignorePatterns ?? defaultValue.ignorePatterns,
+    };
+}
+function profilePatternIds(profile) {
+    if (!profile?.patterns)
+        return [];
+    return Object.entries(profile.patterns)
+        .filter(([, pattern]) => pattern.enabled === true)
+        .map(([id]) => id);
+}
+function checksById(ids) {
+    const byId = new Map(defaultChecks.map((check) => [check.id, check]));
+    return ids.map((id) => {
+        const check = byId.get(id);
+        if (!check)
+            throw new Error(`Unknown check in search profile: ${id}`);
+        return check;
+    });
+}
+function applyPatternOverride(check, override) {
+    if (!override)
+        return check;
+    return {
+        ...check,
+        searchPrompt: override.searchPrompt ?? check.searchPrompt,
+        searchExamples: {
+            match: override.matchExamples ?? check.searchExamples?.match ?? check.examples?.match ?? [],
+            nonMatch: override.nonMatchExamples ?? check.searchExamples?.nonMatch ?? check.examples?.noMatch ?? [],
+        },
+    };
+}
+function positiveInteger(value) {
+    return Number.isInteger(value) && Number(value) > 0 ? Number(value) : null;
+}

package/dist/sem-provider.d.ts

@@ -0,0 +1,2 @@
+import type { SearchCommand, SemChangeSet } from "./types.ts";
+export declare function semChangeSetForCommand(command: SearchCommand): Promise<SemChangeSet>;

package/dist/sem-provider.js

@@ -0,0 +1,247 @@
+import { execFile, spawn } from "node:child_process";
+import { mkdtemp, realpath, rm } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import { cachedJson, fingerprint } from "./cache.js";
+import { readDiffFromStdin } from "./diff.js";
+import { sourceRangeForCommit, sourceRangeForRecentCommits, sourceRangeSince, stagedDiff, } from "./git.js";
+import { sourceId } from "./types.js";
+const execFileAsync = promisify(execFile);
+export async function semChangeSetForCommand(command) {
+    if (command.kind === "stdin")
+        return semChangeSetFromPatch(await readDiffFromStdin(), command.debugSem);
+    if (command.kind === "staged") {
+        const diff = await stagedDiff();
+        if (!diff.text.trim())
+            return emptyChangeSet("staged", diff.stats);
+        return semChangeSetFromPatch(diff.text, command.debugSem, "staged");
+    }
+    if (command.kind === "commit") {
+        const range = await sourceRangeForCommit(command.commit);
+        const raw = await cachedSemDiff(["diff", "--commit", command.commit, "--format", "json"], range, command.debugSem);
+        return withContextWorkspace(normalizeSemDiff(raw, range), command.debugSem);
+    }
+    const range = await semRangeForCommand(command);
+    const raw = await cachedSemDiff(["diff", "--from", range.base, "--to", range.target, "--format", "json"], range, command.debugSem);
+    return withContextWorkspace(normalizeSemDiff(raw, range), command.debugSem);
+}
+function emptyChangeSet(label, stats) {
+    return {
+        id: sourceId(label),
+        label,
+        base: label,
+        target: label,
+        contextCwd: process.cwd(),
+        cleanup: async () => undefined,
+        changes: [],
+        summary: {
+            added: stats.additions,
+            deleted: stats.deletions,
+            modified: 0,
+            moved: 0,
+            renamed: 0,
+            fileCount: stats.filesChanged,
+            total: 0,
+        },
+    };
+}
+async function semRangeForCommand(command) {
+    if (command.kind === "since")
+        return sourceRangeSince(command.since);
+    if (command.kind === "commit")
+        return sourceRangeForCommit(command.commit);
+    if (command.kind === "commits")
+        return sourceRangeForRecentCommits(command.count);
+    throw new Error("sem cannot resolve stdin as a git range.");
+}
+async function semChangeSetFromPatch(patch, debugSem, label = "stdin") {
+    if (!patch.trim())
+        throw new Error("No diff received on stdin.");
+    const raw = await cachedJson("sem-diff", fingerprint({
+        version: 1,
+        cwd: process.cwd(),
+        command: ["diff", "--patch", "--format", "json"],
+        patchHash: fingerprint(patch),
+    }), () => runSemWithInput(["diff", "--patch", "--format", "json"], patch, debugSem));
+    return {
+        ...normalizeSemDiff(raw, {
+            id: sourceId(label),
+            label,
+            base: label,
+            target: label,
+            stats: { filesChanged: 0, additions: 0, deletions: 0 },
+        }),
+        contextCwd: process.cwd(),
+        cleanup: async () => undefined,
+    };
+}
+async function cachedSemDiff(args, range, debugSem) {
+    return cachedJson("sem-diff", fingerprint({
+        version: 1,
+        cwd: process.cwd(),
+        args,
+        base: range.base,
+        target: range.target,
+    }), () => runSem(args, debugSem));
+}
+async function withContextWorkspace(changeSet, debugSem) {
+    const tempDir = await realpath(await mkdtemp(path.join(tmpdir(), "stupify-sem-context-")));
+    let worktreeAdded = false;
+    try {
+        await git(["worktree", "add", "--detach", tempDir, changeSet.target], debugSem);
+        worktreeAdded = true;
+        return {
+            ...changeSet,
+            contextCwd: tempDir,
+            cleanup: async () => cleanupWorktree(tempDir, worktreeAdded, debugSem),
+        };
+    }
+    catch (error) {
+        await cleanupWorktree(tempDir, worktreeAdded, debugSem);
+        throw error;
+    }
+}
+async function runSem(args, debugSem, cwd = process.cwd()) {
+    if (debugSem)
+        console.error(`sem ${args.join(" ")}`);
+    const { command, commandArgs } = resolveSemCommand(args);
+    try {
+        const { stdout, stderr } = await execFileAsync(command, commandArgs, {
+            cwd,
+            maxBuffer: 128 * 1024 * 1024,
+        });
+        if (debugSem && stderr.trim())
+            console.error(stderr.trim());
+        return JSON.parse(stdout);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`sem failed. Install @ataraxy-labs/sem and ensure its binary is downloaded.\n${message}`);
+    }
+}
+async function runSemWithInput(args, stdin, debugSem) {
+    if (debugSem)
+        console.error(`sem ${args.join(" ")}`);
+    const { command, commandArgs } = resolveSemCommand(args);
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, commandArgs, { stdio: ["pipe", "pipe", "pipe"] });
+        const stdout = [];
+        const stderr = [];
+        child.stdout.on("data", (chunk) => stdout.push(chunk));
+        child.stderr.on("data", (chunk) => stderr.push(chunk));
+        child.on("error", (error) => reject(error));
+        child.on("close", (code) => {
+            const stderrText = Buffer.concat(stderr).toString("utf8");
+            if (debugSem && stderrText.trim())
+                console.error(stderrText.trim());
+            if (code !== 0) {
+                reject(new Error(`sem failed with exit code ${code}${stderrText ? `: ${stderrText.trim()}` : ""}`));
+                return;
+            }
+            try {
+                resolve(JSON.parse(Buffer.concat(stdout).toString("utf8")));
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+        child.stdin.end(stdin);
+    });
+}
+async function git(args, debugSem) {
+    if (debugSem)
+        console.error(`git ${args.join(" ")}`);
+    await execFileAsync("git", [...args], { maxBuffer: 128 * 1024 * 1024 });
+}
+async function cleanupWorktree(tempDir, worktreeAdded, debugSem) {
+    if (!worktreeAdded) {
+        await rm(tempDir, { recursive: true, force: true });
+        return;
+    }
+    try {
+        await git(["worktree", "remove", "--force", tempDir], debugSem);
+    }
+    catch {
+        await rm(tempDir, { recursive: true, force: true });
+        await git(["worktree", "prune"], debugSem).catch(() => undefined);
+    }
+}
+function resolveSemCommand(args) {
+    const packageBin = semPackageBin();
+    if (packageBin)
+        return { command: process.execPath, commandArgs: [packageBin, ...args] };
+    return { command: "sem", commandArgs: args };
+}
+function semPackageBin() {
+    try {
+        const require = createRequire(import.meta.url);
+        return require.resolve("@ataraxy-labs/sem/bin/sem.js");
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeSemDiff(value, range) {
+    if (!value || typeof value !== "object")
+        throw new Error("sem returned invalid diff JSON.");
+    const record = value;
+    const changes = Array.isArray(record.changes) ? record.changes.flatMap(normalizeSemChange) : [];
+    const summary = normalizeSemSummary(record.summary, changes);
+    return {
+        id: range.id,
+        label: range.label,
+        base: range.base,
+        target: range.target,
+        contextCwd: process.cwd(),
+        cleanup: async () => undefined,
+        changes,
+        summary,
+    };
+}
+function normalizeSemChange(value) {
+    if (!value || typeof value !== "object")
+        return [];
+    const record = value;
+    const entityId = stringValue(record.entityId);
+    const entityName = stringValue(record.entityName);
+    const entityType = stringValue(record.entityType);
+    const filePath = stringValue(record.filePath);
+    const changeType = stringValue(record.changeType);
+    if (!entityId || !entityName || !entityType || !filePath || !changeType)
+        return [];
+    return [{
+            entityId,
+            entityName,
+            entityType,
+            filePath,
+            changeType,
+            beforeContent: nullableString(record.beforeContent),
+            afterContent: nullableString(record.afterContent),
+        }];
+}
+function normalizeSemSummary(value, changes) {
+    const record = value && typeof value === "object" ? value : {};
+    return {
+        added: numberValue(record.added) ?? countByChange(changes, "added"),
+        deleted: numberValue(record.deleted) ?? countByChange(changes, "deleted"),
+        modified: numberValue(record.modified) ?? countByChange(changes, "modified"),
+        moved: numberValue(record.moved) ?? countByChange(changes, "moved"),
+        renamed: numberValue(record.renamed) ?? countByChange(changes, "renamed"),
+        fileCount: numberValue(record.fileCount) ?? new Set(changes.map((change) => change.filePath)).size,
+        total: numberValue(record.total) ?? changes.length,
+    };
+}
+function countByChange(changes, changeType) {
+    return changes.filter((change) => change.changeType === changeType).length;
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : "";
+}
+function nullableString(value) {
+    return typeof value === "string" ? value : null;
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}

package/dist/stupify.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import type { SearchCommand, SearchRunJson } from "./types.ts";
+export declare function main(argv?: string[]): Promise<number>;
+export declare function runSearchCommand(command: SearchCommand, startedAt: number): Promise<SearchRunJson>;

package/dist/stupify.js

@@ -0,0 +1,237 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { countPromptTokens, runSearch, searchRequest } from "./analysis.js";
+import { searchChecks } from "./checks.js";
+import { parseCommand } from "./command.js";
+import { counterScoutTargets } from "./counter-scout.js";
+import { runDoctor } from "./doctor.js";
+import { runHookCommand } from "./hooks.js";
+import { firstRunModelBootstrap, loadLocalModel } from "./model.js";
+import { entityContextsFromChanges, emptyContextPack, repomixContextPack, repomixSearchConfig } from "./repomix-provider.js";
+import { helpText, renderSearchRun } from "./render.js";
+import { effectiveMaxCandidates, effectiveMaxSearchInputTokens, effectiveRepomixConfig, effectiveSearchChecks, loadSearchProfile, } from "./search-profile.js";
+import { semChangeSetForCommand } from "./sem-provider.js";
+import { createTracer } from "./trace.js";
+export async function main(argv = process.argv.slice(2)) {
+    const startedAt = Date.now();
+    try {
+        const command = parseCommand(argv);
+        if (command.kind === "help") {
+            console.log(helpText());
+            return 0;
+        }
+        if (command.kind === "hook") {
+            console.log(await runHookCommand(command.action));
+            return 0;
+        }
+        if (command.kind === "doctor") {
+            const result = await runDoctor();
+            console.log(result.text);
+            return result.exitCode;
+        }
+        if (command.kind === "bench-search") {
+            const { runSearchBench } = await import("./search-bench.js");
+            console.log(await runSearchBench(command.configPath));
+            return 0;
+        }
+        const run = await runSearchCommand(command, startedAt);
+        console.log(renderSearchRun(run, command));
+        return 0;
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+}
+export async function runSearchCommand(command, startedAt) {
+    const t = createTracer({
+        writeLine: () => undefined,
+        onEvent: (event) => {
+            const parts = [`trace ${event.name}`, `${event.ms}ms`];
+            if (event.count !== undefined)
+                parts.push(`count=${event.count}`);
+            if (event.detail)
+                parts.push(event.detail);
+            console.error(parts.join(" "));
+        },
+    });
+    const profile = await loadSearchProfile(command.searchProfilePath);
+    const checks = profile ? effectiveSearchChecks(command.checkIds, profile) : searchChecks(command.checkIds);
+    const patternIds = checks.map((check) => check.id);
+    const maxCandidates = effectiveMaxCandidates(command.maxCandidates, profile);
+    const maxSearchInputTokens = effectiveMaxSearchInputTokens(command.maxSearchInputTokens, profile);
+    const { value: changeSet } = await t.trace("entity.diff", () => semChangeSetForCommand(command), {
+        count: (v) => v.summary.total,
+        detail: (v) => `${v.summary.fileCount} files`,
+    });
+    try {
+        printRunPlan(command, changeSet.summary.fileCount, changeSet.summary.total, patternIds);
+        const candidates = counterScoutTargets(changeSet, checks, maxCandidates);
+        const contexts = entityContextsFromChanges(candidates, changeSet.changes);
+        const targetsByPattern = countTargetsByPattern(contexts);
+        const targetsPreview = previewTargets(contexts);
+        if (contexts.length === 0) {
+            return {
+                schemaVersion: "search.v1",
+                mode: "search",
+                source: command.source,
+                model: { id: command.model },
+                patterns: patternIds,
+                stats: {
+                    elapsedMs: Date.now() - startedAt,
+                    modelCalls: 0,
+                    skipped: true,
+                    skipReason: "no_candidates",
+                    filesChanged: changeSet.summary.fileCount,
+                    entitiesScanned: changeSet.summary.total,
+                    candidates: 0,
+                    searchTargets: 0,
+                    repomixFiles: 0,
+                    repomixTokens: 0,
+                    profileId: profile?.id,
+                    targetsByPattern,
+                    targetsPreview,
+                },
+                matches: [],
+            };
+        }
+        const baseRepomixConfig = effectiveRepomixConfig(repomixSearchConfig(), profile);
+        const initialPack = profile?.context === "sem"
+            ? emptyContextPack()
+            : await t.trace("context.pack", () => repomixContextPack(changeSet.contextCwd, contexts, changeSet.changes, baseRepomixConfig), {
+                count: (v) => v.filePaths.length,
+                detail: (v) => `${v.totalTokens} tokens`,
+            }).then((result) => result.value);
+        const packedFiles = new Set(initialPack.filePaths);
+        const searchContexts = profile?.context === "sem"
+            ? contexts
+            : contexts.filter((context) => context.filePath && packedFiles.has(context.filePath));
+        if (searchContexts.length === 0) {
+            return {
+                schemaVersion: "search.v1",
+                mode: "search",
+                source: command.source,
+                model: { id: command.model },
+                patterns: patternIds,
+                stats: {
+                    elapsedMs: Date.now() - startedAt,
+                    modelCalls: 0,
+                    skipped: true,
+                    skipReason: "no_candidates",
+                    filesChanged: changeSet.summary.fileCount,
+                    entitiesScanned: changeSet.summary.total,
+                    candidates: contexts.length,
+                    searchTargets: 0,
+                    repomixFiles: initialPack.filePaths.length,
+                    repomixTokens: initialPack.totalTokens,
+                    repomixConfig: initialPack.config,
+                    profileId: profile?.id,
+                    targetsByPattern,
+                    targetsPreview,
+                },
+                matches: [],
+            };
+        }
+        const pack = profile?.context === "sem" || searchContexts.length === contexts.length
+            ? initialPack
+            : await repomixContextPack(changeSet.contextCwd, searchContexts, changeSet.changes, baseRepomixConfig);
+        const modelPath = await firstRunModelBootstrap(command.model);
+        const model = await loadLocalModel(modelPath, command.model, "scout");
+        const request = buildSearchRequest(changeSet, searchContexts, pack, checks, profile, command.includeCounterReasonInPrompt);
+        const inputTokens = await countPromptTokens(model, request.prompt);
+        if (inputTokens > maxSearchInputTokens) {
+            return {
+                schemaVersion: "search.v1",
+                mode: "search",
+                source: command.source,
+                model: { id: command.model },
+                patterns: patternIds,
+                stats: {
+                    elapsedMs: Date.now() - startedAt,
+                    modelCalls: 0,
+                    inputTokens,
+                    inputTokenCap: maxSearchInputTokens,
+                    skipped: true,
+                    skipReason: "input_too_large",
+                    filesChanged: changeSet.summary.fileCount,
+                    entitiesScanned: changeSet.summary.total,
+                    candidates: contexts.length,
+                    searchTargets: searchContexts.length,
+                    repomixFiles: pack.filePaths.length,
+                    repomixTokens: pack.totalTokens,
+                    repomixConfig: pack.config,
+                    profileId: profile?.id,
+                    targetsByPattern: countTargetsByPattern(searchContexts),
+                    targetsPreview: previewTargets(searchContexts),
+                },
+                matches: [],
+            };
+        }
+        const { value: matches } = await t.trace("search.model", () => runSearch(model, request), { count: (v) => v.length });
+        return {
+            schemaVersion: "search.v1",
+            mode: "search",
+            source: command.source,
+            model: { id: command.model },
+            patterns: patternIds,
+            stats: {
+                elapsedMs: Date.now() - startedAt,
+                modelCalls: 1,
+                inputTokens,
+                inputTokenCap: maxSearchInputTokens,
+                filesChanged: changeSet.summary.fileCount,
+                entitiesScanned: changeSet.summary.total,
+                candidates: contexts.length,
+                searchTargets: searchContexts.length,
+                repomixFiles: pack.filePaths.length,
+                repomixTokens: pack.totalTokens,
+                repomixConfig: pack.config,
+                profileId: profile?.id,
+                targetsByPattern: countTargetsByPattern(searchContexts),
+                targetsPreview: previewTargets(searchContexts),
+            },
+            matches,
+        };
+    }
+    finally {
+        await changeSet.cleanup();
+    }
+}
+function buildSearchRequest(changeSet, contexts, pack, patterns, profile, includeCounterReasonInPrompt) {
+    return searchRequest({
+        changeSet,
+        contexts,
+        pack,
+        patterns,
+        includeCounterReasonInPrompt: profile?.includeCounterReasonInPrompt ?? includeCounterReasonInPrompt,
+    });
+}
+function printRunPlan(command, filesChanged, entitiesScanned, patternIds) {
+    if (command.json)
+        return;
+    console.error("🧙 stupify 🪄");
+    console.error(`Mode: search (${command.source})`);
+    console.error(`Sem: ${filesChanged} files, ${entitiesScanned} changed entities`);
+    console.error(`Patterns: ${patternIds.join(", ")}`);
+}
+function countTargetsByPattern(contexts) {
+    const counts = {};
+    for (const context of contexts)
+        counts[context.checkId] = (counts[context.checkId] ?? 0) + 1;
+    return counts;
+}
+function previewTargets(contexts) {
+    return contexts.map((context) => ({
+        targetId: context.targetId,
+        patternId: context.checkId,
+        entityKind: context.entityKind || undefined,
+        sourceKind: context.filePath ? pathKind(context.filePath) : undefined,
+    }));
+}
+function pathKind(filePath) {
+    const ext = filePath.split(".").pop();
+    return ext && ext !== filePath ? ext : "unknown";
+}
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+    process.exitCode = await main();
+}

package/dist/trace.d.ts

@@ -0,0 +1,29 @@
+export type TraceFields = Record<string, string | number | boolean | null | undefined>;
+export type Tracer = {
+    trace<T>(span: string, fn: () => Promise<T>, options?: SpanTraceOptions<T>): Promise<{
+        value: T;
+        ms: number;
+    }>;
+    trace<T>(span: string, fn: () => T, options?: SpanTraceOptions<T>): {
+        value: T;
+        ms: number;
+    };
+};
+export type SpanTraceEvent = Readonly<{
+    name: string;
+    ms: number;
+    count?: number;
+    detail?: string;
+}>;
+export type SpanTraceOptions<T> = Readonly<{
+    fields?: TraceFields;
+    count?: (value: T) => number;
+    detail?: (value: T) => string;
+}>;
+export type CreateTracerOptions = {
+    enabled?: boolean;
+    writeLine?: (line: string) => void;
+    onEvent?: (event: SpanTraceEvent) => void;
+};
+export declare function createTracer(options?: CreateTracerOptions): Tracer;
+export declare const trace: Tracer;

package/dist/trace.js

@@ -0,0 +1,64 @@
+import { performance } from "node:perf_hooks";
+export function createTracer(options) {
+    const enabled = options?.enabled ?? true;
+    const writeLine = options?.writeLine ?? ((line) => process.stderr.write(line + "\n"));
+    const onEvent = options?.onEvent;
+    const nowMs = () => performance.now();
+    function emit(span, durationMs, fields) {
+        if (!enabled)
+            return;
+        const payload = { span, ms: Math.round(durationMs) };
+        for (const [k, v] of Object.entries(fields ?? {})) {
+            if (v !== undefined)
+                payload[k] = v;
+        }
+        writeLine(`trace ${JSON.stringify(payload)}`);
+    }
+    function trace(span, fn, options) {
+        const startedAtMs = nowMs();
+        try {
+            const out = fn();
+            if (isPromiseLike(out)) {
+                return (async () => {
+                    let durationMs;
+                    try {
+                        const value = await out;
+                        durationMs = nowMs() - startedAtMs;
+                        const event = {
+                            name: span,
+                            ms: Math.round(durationMs),
+                            count: options?.count?.(value),
+                            detail: options?.detail?.(value),
+                        };
+                        onEvent?.(event);
+                        return { value, ms: event.ms };
+                    }
+                    finally {
+                        durationMs ??= nowMs() - startedAtMs;
+                        emit(span, durationMs, options?.fields);
+                    }
+                })();
+            }
+            const durationMs = nowMs() - startedAtMs;
+            emit(span, durationMs, options?.fields);
+            const event = {
+                name: span,
+                ms: Math.round(durationMs),
+                count: options?.count?.(out),
+                detail: options?.detail?.(out),
+            };
+            onEvent?.(event);
+            return { value: out, ms: event.ms };
+        }
+        catch (error) {
+            const durationMs = nowMs() - startedAtMs;
+            emit(span, durationMs, options?.fields);
+            throw error;
+        }
+    }
+    return { trace };
+}
+export const trace = createTracer();
+function isPromiseLike(value) {
+    return typeof value === "object" && value !== null && "then" in value;
+}