ushman-characterize 0.4.0

package/dist/schema-types.d.ts

@@ -0,0 +1,40 @@
+import * as v from 'valibot';
+export declare const StateDagActionSchema: v.VariantSchema<"type", [v.ObjectSchema<{
+    readonly selector: v.StringSchema<undefined>;
+    readonly type: v.LiteralSchema<"click", undefined>;
+    readonly waitMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly ms: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly type: v.LiteralSchema<"wait", undefined>;
+}, undefined>], undefined>;
+export type StateDagAction = v.InferOutput<typeof StateDagActionSchema>;
+export declare const StateDagDocumentSchema: v.ObjectSchema<{
+    readonly states: v.RecordSchema<v.StringSchema<undefined>, v.ObjectSchema<{
+        readonly actions: v.OptionalSchema<v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
+            readonly selector: v.StringSchema<undefined>;
+            readonly type: v.LiteralSchema<"click", undefined>;
+            readonly waitMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly ms: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly type: v.LiteralSchema<"wait", undefined>;
+        }, undefined>], undefined>, undefined>, undefined>;
+        readonly frameStability: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>, undefined>;
+        readonly preconditions: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+    }, undefined>, undefined>;
+    readonly createdAt: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly schemaName: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly schemaVersion: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly ushmanVersion: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+export type StateDagDocument = v.InferOutput<typeof StateDagDocumentSchema>;
+export declare const V3WorkspaceIdDocumentSchema: v.ObjectSchema<{
+    readonly donorOriginUrl: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+    readonly packageHash: v.StringSchema<undefined>;
+    readonly shibukLobbyId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly createdAt: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly schemaName: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly schemaVersion: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly ushmanVersion: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+export type V3WorkspaceIdDocument = v.InferOutput<typeof V3WorkspaceIdDocumentSchema>;
+//# sourceMappingURL=schema-types.d.ts.map

package/dist/schema-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-types.d.ts","sourceRoot":"","sources":["../src/schema-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAoB7B,eAAO,MAAM,oBAAoB;;;;;;;0BAA2E,CAAC;AAC7G,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAQxE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;aAGjC,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE5E,eAAO,MAAM,2BAA2B;;;;;;;;aAKtC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,2BAA2B,CAAC,CAAC"}

package/dist/schema-types.js

@@ -0,0 +1,32 @@
+import * as v from 'valibot';
+const VersionedFields = {
+    createdAt: v.optional(v.string()),
+    schemaName: v.optional(v.string()),
+    schemaVersion: v.optional(v.string()),
+    ushmanVersion: v.optional(v.string()),
+};
+const StateDagClickActionSchema = v.object({
+    selector: v.string(),
+    type: v.literal('click'),
+    waitMs: v.optional(v.pipe(v.number(), v.integer(), v.minValue(0))),
+});
+const StateDagWaitActionSchema = v.object({
+    ms: v.pipe(v.number(), v.integer(), v.minValue(0)),
+    type: v.literal('wait'),
+});
+export const StateDagActionSchema = v.variant('type', [StateDagClickActionSchema, StateDagWaitActionSchema]);
+const StateDagNodeSchema = v.object({
+    actions: v.optional(v.array(StateDagActionSchema)),
+    frameStability: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1))),
+    preconditions: v.optional(v.array(v.string())),
+});
+export const StateDagDocumentSchema = v.object({
+    ...VersionedFields,
+    states: v.record(v.string(), StateDagNodeSchema),
+});
+export const V3WorkspaceIdDocumentSchema = v.object({
+    ...VersionedFields,
+    donorOriginUrl: v.optional(v.nullable(v.string())),
+    packageHash: v.string(),
+    shibukLobbyId: v.optional(v.string()),
+});

package/dist/seed-scaffolds.d.ts

@@ -0,0 +1,31 @@
+export declare const SEED_FINGERPRINT_SCHEMA_VERSION = "shibuk-seed-fingerprints/v1";
+export declare const SEED_FINGERPRINT_SIDECAR_RELATIVE_PATH: string;
+export declare const PARITY_BASELINE_RELATIVE_DIR: string;
+export declare const hashSeedScaffoldContent: (value: string) => string;
+export declare const toPosixPath: (value: string) => string;
+export declare const toWorkspaceRelativePath: ({ filePath, workspaceDir, }: {
+    readonly filePath: string;
+    readonly workspaceDir: string;
+}) => string;
+/**
+ * Load the seed scaffold fingerprint sidecar. Missing files are represented as an empty map
+ * so callers can decide whether the workspace should be treated as unmanaged or re-seeded.
+ */
+export declare const loadSeedFingerprintSidecar: (workspaceDir: string) => Promise<{
+    exists: boolean;
+    filePath: string;
+    scaffolds: Record<string, string>;
+}>;
+/**
+ * Merge updated scaffold fingerprints, prune entries whose files no longer exist, and avoid
+ * rewriting the sidecar when the normalized fingerprint map is unchanged.
+ */
+export declare const updateSeedFingerprintSidecar: ({ entries, workspaceDir, }: {
+    readonly entries: Record<string, string>;
+    readonly workspaceDir: string;
+}) => Promise<string>;
+export declare const listFilesRecursive: ({ dir, suffix, }: {
+    readonly dir: string;
+    readonly suffix: string;
+}) => Promise<string[]>;
+//# sourceMappingURL=seed-scaffolds.d.ts.map

package/dist/seed-scaffolds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seed-scaffolds.d.ts","sourceRoot":"","sources":["../src/seed-scaffolds.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,+BAA+B,gCAAgC,CAAC;AAC7E,eAAO,MAAM,sCAAsC,QAAgD,CAAC;AACpG,eAAO,MAAM,4BAA4B,QAAkC,CAAC;AAO5E,eAAO,MAAM,uBAAuB,GAAI,OAAO,MAAM,WAIpD,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,WAAoC,CAAC;AAE9E,eAAO,MAAM,uBAAuB,GAAI,6BAGrC;IACC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CACjC,WAAuD,CAAC;AA4BzD;;;GAGG;AACH,eAAO,MAAM,0BAA0B,GAAU,cAAc,MAAM;;;eAOxC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;EASlD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,4BAA4B,GAAU,4BAGhD;IACC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CACjC,oBAwBA,CAAC;AAWF,eAAO,MAAM,kBAAkB,GAAU,kBAGtC;IACC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CAC3B,KAAG,OAAO,CAAC,MAAM,EAAE,CAgBnB,CAAC"}

package/dist/seed-scaffolds.js

@@ -0,0 +1,96 @@
+import { mkdir, readdir } from 'node:fs/promises';
+import path from 'node:path';
+import { atomicWriteJson } from "./workspace-paths.js";
+export const SEED_FINGERPRINT_SCHEMA_VERSION = 'shibuk-seed-fingerprints/v1';
+export const SEED_FINGERPRINT_SIDECAR_RELATIVE_PATH = path.join('tests', '.seed-fingerprints.json');
+export const PARITY_BASELINE_RELATIVE_DIR = path.join('parity', 'baseline');
+export const hashSeedScaffoldContent = (value) => {
+    const hasher = new Bun.CryptoHasher('sha256');
+    hasher.update(value);
+    return hasher.digest('hex');
+};
+export const toPosixPath = (value) => value.split(path.sep).join('/');
+export const toWorkspaceRelativePath = ({ filePath, workspaceDir, }) => toPosixPath(path.relative(workspaceDir, filePath));
+const seedFingerprintSidecarPath = (workspaceDir) => path.join(workspaceDir, SEED_FINGERPRINT_SIDECAR_RELATIVE_PATH);
+const isRecord = (value) => typeof value === 'object' && value !== null;
+const assertSeedFingerprintSidecar = (value) => {
+    if (!isRecord(value) || value.schemaVersion !== SEED_FINGERPRINT_SCHEMA_VERSION || !isRecord(value.scaffolds)) {
+        throw new Error(`tests/.seed-fingerprints.json must be ${SEED_FINGERPRINT_SCHEMA_VERSION}. Re-run seed scaffolding or restore the sidecar.`);
+    }
+    const scaffolds = {};
+    for (const [key, entry] of Object.entries(value.scaffolds)) {
+        if (typeof entry !== 'string') {
+            throw new Error(`tests/.seed-fingerprints.json has a non-string fingerprint for "${key}".`);
+        }
+        scaffolds[key] = entry;
+    }
+    return {
+        scaffolds,
+        schemaVersion: SEED_FINGERPRINT_SCHEMA_VERSION,
+    };
+};
+/**
+ * Load the seed scaffold fingerprint sidecar. Missing files are represented as an empty map
+ * so callers can decide whether the workspace should be treated as unmanaged or re-seeded.
+ */
+export const loadSeedFingerprintSidecar = async (workspaceDir) => {
+    const filePath = seedFingerprintSidecarPath(workspaceDir);
+    const file = Bun.file(filePath);
+    if (!(await file.exists())) {
+        return {
+            exists: false,
+            filePath,
+            scaffolds: {},
+        };
+    }
+    return {
+        exists: true,
+        filePath,
+        scaffolds: assertSeedFingerprintSidecar(await file.json()).scaffolds,
+    };
+};
+/**
+ * Merge updated scaffold fingerprints, prune entries whose files no longer exist, and avoid
+ * rewriting the sidecar when the normalized fingerprint map is unchanged.
+ */
+export const updateSeedFingerprintSidecar = async ({ entries, workspaceDir, }) => {
+    const current = await loadSeedFingerprintSidecar(workspaceDir);
+    const nextScaffolds = Object.fromEntries((await Promise.all(Object.entries({
+        ...current.scaffolds,
+        ...entries,
+    }).map(async ([relativePath, fingerprint]) => {
+        const absolutePath = path.join(workspaceDir, relativePath);
+        return (await Bun.file(absolutePath).exists()) ? [relativePath, fingerprint] : null;
+    }))).filter((entry) => entry !== null));
+    if (stableFingerprintMapsEqual(current.scaffolds, nextScaffolds)) {
+        return current.filePath;
+    }
+    await mkdir(path.dirname(current.filePath), { recursive: true });
+    await atomicWriteJson(current.filePath, {
+        scaffolds: nextScaffolds,
+        schemaVersion: SEED_FINGERPRINT_SCHEMA_VERSION,
+    });
+    return current.filePath;
+};
+const stableFingerprintMapsEqual = (left, right) => {
+    const leftKeys = Object.keys(left).sort((first, second) => first.localeCompare(second));
+    const rightKeys = Object.keys(right).sort((first, second) => first.localeCompare(second));
+    if (leftKeys.length !== rightKeys.length) {
+        return false;
+    }
+    return leftKeys.every((key, index) => key === rightKeys[index] && left[key] === right[key]);
+};
+export const listFilesRecursive = async ({ dir, suffix, }) => {
+    const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+    const files = await Promise.all(entries.map(async (entry) => {
+        const absolutePath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            return listFilesRecursive({
+                dir: absolutePath,
+                suffix,
+            });
+        }
+        return entry.isFile() && absolutePath.endsWith(suffix) ? [absolutePath] : [];
+    }));
+    return files.flat().sort((left, right) => left.localeCompare(right));
+};

package/dist/shared.d.ts

@@ -0,0 +1,36 @@
+import { type NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+export type BundleBindingKind = 'class' | 'function' | 'import' | 'variable';
+export type BundleBinding = {
+    readonly kind: BundleBindingKind;
+    readonly name: string;
+    readonly path: NodePath<t.Statement | t.ModuleDeclaration>;
+    readonly sortableStart: number;
+    readonly statement: t.Statement | t.ModuleDeclaration;
+};
+export type BundleAst = {
+    readonly ast: t.File;
+    readonly bindings: ReadonlyMap<string, BundleBinding>;
+    readonly exportedNames: ReadonlySet<string>;
+    readonly programPath: NodePath<t.Program>;
+    readonly source: string;
+    readonly sourcePath: string;
+};
+export declare const parseBundleAst: ({ source, sourcePath, }: {
+    readonly source: string;
+    readonly sourcePath: string;
+}) => BundleAst;
+export declare const sanitizeSymbolName: (value: string) => string;
+export declare const relativeImportPath: ({ fromFile, toFile }: {
+    readonly fromFile: string;
+    readonly toFile: string;
+}) => string;
+export declare const stableJsonStringify: (value: unknown, indent?: number) => string;
+export declare const buildStandaloneSymbolModule: ({ bindingName, bundle, outputFilePath, }: {
+    readonly bindingName: string;
+    readonly bundle: BundleAst;
+    readonly outputFilePath?: string;
+}) => string;
+export declare const parseJsonLines: <T>(text: string) => T[];
+export declare const toJsonLines: (rows: readonly unknown[]) => string;
+//# sourceMappingURL=shared.d.ts.map

package/dist/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../src/shared.ts"],"names":[],"mappings":"AAGA,OAAiB,EAAE,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAIlC,MAAM,MAAM,iBAAiB,GAAG,OAAO,GAAG,UAAU,GAAG,QAAQ,GAAG,UAAU,CAAC;AAE7E,MAAM,MAAM,aAAa,GAAG;IACxB,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC,iBAAiB,CAAC,CAAC;IAC3D,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC,iBAAiB,CAAC;CACzD,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACpB,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC;IACrB,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IACtD,QAAQ,CAAC,aAAa,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC5C,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;IAC1C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC/B,CAAC;AAwLF,eAAO,MAAM,cAAc,GAAI,yBAG5B;IACC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC/B,KAAG,SAyCH,CAAC;AA0MF,eAAO,MAAM,kBAAkB,GAAI,OAAO,MAAM,WAAqC,CAAC;AAEtF,eAAO,MAAM,kBAAkB,GAAI,sBAAsB;IAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,WAG9G,CAAC;AAgBF,eAAO,MAAM,mBAAmB,GAAI,OAAO,OAAO,EAAE,SAAS,MAAM,WACP,CAAC;AAE7D,eAAO,MAAM,2BAA2B,GAAI,0CAIzC;IACC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAC3B,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CACpC,WA4CA,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,CAAC,EAAE,MAAM,MAAM,KAAG,CAAC,EAaxC,CAAC;AAEX,eAAO,MAAM,WAAW,GAAI,MAAM,SAAS,OAAO,EAAE,WAA2D,CAAC"}

package/dist/shared.js

@@ -0,0 +1,390 @@
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import generate from '@babel/generator';
+import traverse, {} from '@babel/traverse';
+import * as t from '@babel/types';
+import { parseModuleAst } from "./babel-config.js";
+import { getAnonymousDefaultExportBindingName, isAnonymousDefaultExportCallableStatement } from "./default-export.js";
+const MAX_STATEMENT_DEPENDENCIES = 2_048;
+const unwrapStatement = (statement) => {
+    if (t.isExportNamedDeclaration(statement) || t.isExportDefaultDeclaration(statement)) {
+        return statement.declaration ?? statement;
+    }
+    return statement;
+};
+const addNamedBinding = ({ bindings, kind, name, path: statementPath, statement, }) => {
+    if (bindings.has(name)) {
+        return;
+    }
+    bindings.set(name, {
+        kind,
+        name,
+        path: statementPath,
+        sortableStart: statement.start ?? 0,
+        statement,
+    });
+};
+const collectNamedExportSpecifierNames = (statement) => {
+    const names = [];
+    for (const specifier of statement.specifiers) {
+        if (t.isExportSpecifier(specifier) && t.isIdentifier(specifier.exported)) {
+            names.push(specifier.exported.name);
+        }
+    }
+    return names;
+};
+const collectDeclarationExportNames = (declaration) => {
+    if ((t.isFunctionDeclaration(declaration) || t.isClassDeclaration(declaration)) && declaration.id) {
+        return [declaration.id.name];
+    }
+    if (!t.isVariableDeclaration(declaration)) {
+        return [];
+    }
+    return declaration.declarations
+        .map((declarator) => (t.isIdentifier(declarator.id) ? declarator.id.name : null))
+        .filter((name) => name !== null);
+};
+const collectExportedNames = ({ anonymousDefaultExportBindingName, exportedNames, statement, }) => {
+    if (t.isExportNamedDeclaration(statement)) {
+        for (const name of collectNamedExportSpecifierNames(statement)) {
+            exportedNames.add(name);
+        }
+        if (statement.declaration) {
+            for (const name of collectDeclarationExportNames(statement.declaration)) {
+                exportedNames.add(name);
+            }
+        }
+        return;
+    }
+    if (!t.isExportDefaultDeclaration(statement)) {
+        return;
+    }
+    if ((t.isFunctionDeclaration(statement.declaration) || t.isClassDeclaration(statement.declaration)) &&
+        statement.declaration.id) {
+        exportedNames.add(statement.declaration.id.name);
+        return;
+    }
+    if (anonymousDefaultExportBindingName && isAnonymousDefaultExportCallableStatement(statement)) {
+        exportedNames.add(anonymousDefaultExportBindingName);
+    }
+};
+const collectBindingsFromVariableDeclaration = ({ bindings, path: statementPath, statement, variableDeclaration, }) => {
+    for (const declarator of variableDeclaration.declarations) {
+        if (!t.isIdentifier(declarator.id)) {
+            continue;
+        }
+        addNamedBinding({
+            bindings,
+            kind: 'variable',
+            name: declarator.id.name,
+            path: statementPath,
+            statement,
+        });
+    }
+};
+const collectBindingsFromStatement = ({ anonymousDefaultExportBindingName, bindings, path: statementPath, statement, }) => {
+    if (anonymousDefaultExportBindingName && isAnonymousDefaultExportCallableStatement(statement)) {
+        addNamedBinding({
+            bindings,
+            kind: 'function',
+            name: anonymousDefaultExportBindingName,
+            path: statementPath,
+            statement,
+        });
+        return;
+    }
+    const unwrapped = unwrapStatement(statement);
+    if (t.isFunctionDeclaration(unwrapped) && unwrapped.id) {
+        addNamedBinding({
+            bindings,
+            kind: 'function',
+            name: unwrapped.id.name,
+            path: statementPath,
+            statement,
+        });
+        return;
+    }
+    if (t.isClassDeclaration(unwrapped) && unwrapped.id) {
+        addNamedBinding({
+            bindings,
+            kind: 'class',
+            name: unwrapped.id.name,
+            path: statementPath,
+            statement,
+        });
+        return;
+    }
+    if (t.isImportDeclaration(unwrapped)) {
+        for (const specifier of unwrapped.specifiers) {
+            addNamedBinding({
+                bindings,
+                kind: 'import',
+                name: specifier.local.name,
+                path: statementPath,
+                statement,
+            });
+        }
+        return;
+    }
+    if (t.isVariableDeclaration(unwrapped)) {
+        collectBindingsFromVariableDeclaration({
+            bindings,
+            path: statementPath,
+            statement,
+            variableDeclaration: unwrapped,
+        });
+    }
+};
+export const parseBundleAst = ({ source, sourcePath, }) => {
+    const ast = parseModuleAst({
+        source,
+        sourcePath,
+    });
+    const bindings = new Map();
+    const exportedNames = new Set();
+    const anonymousDefaultExportBindingName = getAnonymousDefaultExportBindingName(ast.program.body);
+    let programPath = null;
+    traverse(ast, {
+        Program(path) {
+            programPath = path;
+            for (const statementPath of path.get('body')) {
+                collectExportedNames({
+                    anonymousDefaultExportBindingName,
+                    exportedNames,
+                    statement: statementPath.node,
+                });
+                collectBindingsFromStatement({
+                    anonymousDefaultExportBindingName,
+                    bindings,
+                    path: statementPath,
+                    statement: statementPath.node,
+                });
+            }
+        },
+    });
+    if (!programPath) {
+        throw new Error(`Failed to parse ${sourcePath}: missing Program path.`);
+    }
+    return {
+        ast,
+        bindings,
+        exportedNames,
+        programPath,
+        source,
+        sourcePath,
+    };
+};
+const isLocalReference = (identifierPath) => {
+    if (!identifierPath.isReferencedIdentifier()) {
+        return false;
+    }
+    const parent = identifierPath.parentPath;
+    if (parent.isObjectProperty({ computed: false }) && parent.node.key === identifierPath.node) {
+        return false;
+    }
+    if (parent.isClassMethod() || parent.isClassProperty() || parent.isObjectMethod()) {
+        return false;
+    }
+    return true;
+};
+const collectStatementDependencies = ({ bundle, rootName, seenNames, }) => {
+    if (seenNames.has(rootName)) {
+        return;
+    }
+    if (seenNames.size >= MAX_STATEMENT_DEPENDENCIES) {
+        throw new Error(`Exceeded standalone dependency limit (${MAX_STATEMENT_DEPENDENCIES}) while extracting "${rootName}" from ${bundle.sourcePath}.`);
+    }
+    seenNames.add(rootName);
+    const binding = bundle.bindings.get(rootName);
+    if (!binding) {
+        return;
+    }
+    binding.path.traverse({
+        Identifier(identifierPath) {
+            if (!isLocalReference(identifierPath)) {
+                return;
+            }
+            const identifierName = identifierPath.node.name;
+            if (identifierName === rootName) {
+                return;
+            }
+            const target = bundle.bindings.get(identifierName);
+            if (!target) {
+                return;
+            }
+            const resolvedBinding = identifierPath.scope.getBinding(identifierName);
+            if (!resolvedBinding || resolvedBinding.scope !== bundle.programPath.scope) {
+                return;
+            }
+            collectStatementDependencies({
+                bundle,
+                rootName: identifierName,
+                seenNames,
+            });
+        },
+    });
+};
+const rewriteImportSpecifier = ({ outputFilePath, sourcePath, specifier, }) => {
+    if (!outputFilePath) {
+        return specifier;
+    }
+    let absoluteSource;
+    if (specifier.startsWith('.')) {
+        absoluteSource = path.resolve(path.dirname(sourcePath), specifier);
+    }
+    else {
+        try {
+            const resolvedUrl = import.meta.resolve(specifier, pathToFileURL(sourcePath).href);
+            absoluteSource = resolvedUrl.startsWith('file:') ? fileURLToPath(resolvedUrl) : specifier;
+        }
+        catch {
+            return specifier;
+        }
+    }
+    return relativeImportPath({
+        fromFile: outputFilePath,
+        toFile: absoluteSource,
+    });
+};
+const normalizeWrappedExportDeclaration = ({ bindingName, outputFilePath, sourcePath, statement, }) => {
+    if (!statement.declaration || !t.isDeclaration(statement.declaration)) {
+        return null;
+    }
+    return normalizeEmittedStatement({
+        bindingName,
+        outputFilePath,
+        sourcePath,
+        statement: statement.declaration,
+    });
+};
+const materializeDefaultExportDeclaration = ({ bindingName, declaration, }) => {
+    if (t.isFunctionDeclaration(declaration) || t.isClassDeclaration(declaration)) {
+        if (declaration.id) {
+            return t.cloneNode(declaration, true);
+        }
+        if (!bindingName) {
+            return null;
+        }
+        const namedDeclaration = t.cloneNode(declaration, true);
+        namedDeclaration.id = t.identifier(bindingName);
+        return namedDeclaration;
+    }
+    if (t.isFunctionExpression(declaration) ||
+        t.isArrowFunctionExpression(declaration) ||
+        t.isClassExpression(declaration)) {
+        if (!bindingName) {
+            return null;
+        }
+        return t.variableDeclaration('const', [
+            t.variableDeclarator(t.identifier(bindingName), t.cloneNode(declaration, true)),
+        ]);
+    }
+    return null;
+};
+const normalizeEmittedStatement = ({ bindingName, outputFilePath, sourcePath, statement, }) => {
+    const unwrapped = unwrapStatement(statement);
+    if (t.isExportNamedDeclaration(statement)) {
+        return normalizeWrappedExportDeclaration({
+            bindingName,
+            outputFilePath,
+            sourcePath,
+            statement,
+        });
+    }
+    if (t.isExportDefaultDeclaration(statement)) {
+        const materialized = materializeDefaultExportDeclaration({
+            bindingName,
+            declaration: statement.declaration,
+        });
+        if (materialized) {
+            return materialized;
+        }
+        return normalizeWrappedExportDeclaration({
+            bindingName,
+            outputFilePath,
+            sourcePath,
+            statement,
+        });
+    }
+    if (t.isImportDeclaration(unwrapped)) {
+        const nextImport = t.cloneNode(unwrapped, true);
+        nextImport.source = t.stringLiteral(rewriteImportSpecifier({
+            outputFilePath,
+            sourcePath,
+            specifier: nextImport.source.value,
+        }));
+        return nextImport;
+    }
+    return t.cloneNode(statement, true);
+};
+export const sanitizeSymbolName = (value) => value.replace(/[^\w.-]+/gu, '_');
+export const relativeImportPath = ({ fromFile, toFile }) => {
+    const rel = path.relative(path.dirname(fromFile), toFile).split(path.sep).join('/');
+    return rel.startsWith('.') ? rel : `./${rel}`;
+};
+const sortStableJsonValue = (value) => {
+    if (Array.isArray(value)) {
+        return value.map((entry) => sortStableJsonValue(entry));
+    }
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entry]) => [key, sortStableJsonValue(entry)]));
+    }
+    return value;
+};
+export const stableJsonStringify = (value, indent) => JSON.stringify(sortStableJsonValue(value), null, indent);
+export const buildStandaloneSymbolModule = ({ bindingName, bundle, outputFilePath, }) => {
+    if (!bundle.bindings.has(bindingName)) {
+        throw new Error(`Unable to extract symbol "${bindingName}" from ${bundle.sourcePath}.`);
+    }
+    const requiredNames = new Set();
+    collectStatementDependencies({
+        bundle,
+        rootName: bindingName,
+        seenNames: requiredNames,
+    });
+    const statements = [];
+    const seenStatements = new Set();
+    for (const entry of [...requiredNames]
+        .map((name) => bundle.bindings.get(name))
+        .filter((binding) => binding !== undefined)
+        .sort((left, right) => left.sortableStart - right.sortableStart)) {
+        if (seenStatements.has(entry.statement)) {
+            continue;
+        }
+        seenStatements.add(entry.statement);
+        const normalized = normalizeEmittedStatement({
+            bindingName: entry.name,
+            outputFilePath,
+            sourcePath: bundle.sourcePath,
+            statement: entry.statement,
+        });
+        if (normalized) {
+            statements.push(normalized);
+        }
+    }
+    const program = t.program([
+        ...statements,
+        t.exportNamedDeclaration(null, [t.exportSpecifier(t.identifier(bindingName), t.identifier(bindingName))], null),
+    ]);
+    return generate(program, {
+        comments: true,
+        compact: false,
+        concise: false,
+        retainLines: false,
+    }).code;
+};
+export const parseJsonLines = (text) => text
+    .split(/\r?\n/u)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line, index) => {
+    try {
+        return JSON.parse(line);
+    }
+    catch (error) {
+        throw new Error(`Invalid JSONL at line ${index + 1}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+});
+export const toJsonLines = (rows) => rows.map((row) => stableJsonStringify(row)).join('\n');

package/dist/state-dag.d.ts

@@ -0,0 +1,5 @@
+import type { StateDagAction, StateDagDocument } from './schema-types.ts';
+export declare const resolveStateDagOrder: (document: StateDagDocument, stateId: string) => string[];
+export declare const collectStateDagActions: (document: StateDagDocument, stateId: string) => StateDagAction[];
+export type { StateDagDocument };
+//# sourceMappingURL=state-dag.d.ts.map

package/dist/state-dag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-dag.d.ts","sourceRoot":"","sources":["../src/state-dag.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE1E,eAAO,MAAM,oBAAoB,GAAI,UAAU,gBAAgB,EAAE,SAAS,MAAM,KAAG,MAAM,EA2BxF,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,UAAU,gBAAgB,EAAE,SAAS,MAAM,KAAG,cAAc,EACJ,CAAC;AAEhG,YAAY,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/state-dag.js

@@ -0,0 +1,27 @@
+export const resolveStateDagOrder = (document, stateId) => {
+    const visiting = new Set();
+    const visited = new Set();
+    const order = [];
+    const visit = (id) => {
+        if (visited.has(id)) {
+            return;
+        }
+        if (visiting.has(id)) {
+            throw new Error(`state-dag cycle detected at "${id}"`);
+        }
+        const node = document.states[id];
+        if (!node) {
+            throw new Error(`state "${id}" is not defined in state-dag.json`);
+        }
+        visiting.add(id);
+        for (const dep of node.preconditions ?? []) {
+            visit(dep);
+        }
+        visiting.delete(id);
+        visited.add(id);
+        order.push(id);
+    };
+    visit(stateId);
+    return order;
+};
+export const collectStateDagActions = (document, stateId) => resolveStateDagOrder(document, stateId).flatMap((id) => document.states[id]?.actions ?? []);