@danielfgray/pg-sourcerer 0.1.0

package/dist/lib/conjure.js

@@ -0,0 +1,697 @@
+/**
+ * Conjure - AST Builder DSL for recast
+ *
+ * A fluent, immutable API for constructing JavaScript/TypeScript AST nodes.
+ * Wraps recast builders with ergonomic patterns for common code generation tasks.
+ *
+ * @example
+ * ```typescript
+ * import { conjure, cast } from "../lib/conjure.js"
+ *
+ * // Method chains
+ * const schema = conjure.id("z")
+ *   .method("string")
+ *   .method("uuid")
+ *   .method("nullable")
+ *   .build()
+ *
+ * // Object literals
+ * const config = conjure.obj()
+ *   .prop("path", conjure.str("/users"))
+ *   .prop("method", conjure.str("GET"))
+ *   .build()
+ *
+ * // Functions
+ * const handler = conjure.fn()
+ *   .async()
+ *   .arrow()
+ *   .param("req", conjure.ts.ref("Request"))
+ *   .param("res", conjure.ts.ref("Response"))
+ *   .body(
+ *     conjure.stmt.return(conjure.id("res").method("json", [data]).build())
+ *   )
+ *   .build()
+ * ```
+ */
+import recast from "recast";
+const b = recast.types.builders;
+// =============================================================================
+// Recast Interop Types
+// =============================================================================
+/**
+ * The ast-types library uses "Kind" union types that are incompatible with
+ * exactOptionalPropertyTypes. We define explicit cast functions that convert
+ * from the namedTypes interfaces (n.Expression, n.Statement, etc.) to the
+ * Kind types that recast builders expect.
+ *
+ * This is safe because every member of n.Expression is a member of ExpressionKind.
+ */
+/** Cast n.Expression to ExpressionKind for recast builder compatibility */
+function toExpr(node) {
+    return node;
+}
+/** Cast n.Statement to StatementKind for recast builder compatibility */
+function toStmt(node) {
+    return node;
+}
+/** Cast n.TSType to TSTypeKind for recast builder compatibility */
+function toTSType(node) {
+    return node;
+}
+// =============================================================================
+// Type Casts (Public API)
+// =============================================================================
+/**
+ * Type cast helpers for raw recast interop.
+ *
+ * Use these when mixing conjure with direct recast builder calls.
+ * These provide the same functionality as the internal cast functions
+ * but are exported for external use.
+ */
+export const cast = {
+    /** Cast n.Expression to ExpressionKind */
+    toExpr,
+    /** Cast array element (expression or spread) */
+    asArrayElem: (node) => node,
+    /** Cast n.Statement to StatementKind */
+    toStmt,
+    /** Cast n.TSType to TSTypeKind */
+    toTSType,
+};
+function createChain(start) {
+    return {
+        node: start,
+        prop(name) {
+            return createChain(b.memberExpression(toExpr(this.node), b.identifier(name)));
+        },
+        method(name, args = []) {
+            return createChain(b.callExpression(b.memberExpression(toExpr(this.node), b.identifier(name)), args.map(toExpr)));
+        },
+        call(args = []) {
+            return createChain(b.callExpression(toExpr(this.node), args.map(toExpr)));
+        },
+        index(expr) {
+            return createChain(b.memberExpression(toExpr(this.node), toExpr(expr), true));
+        },
+        build() {
+            return this.node;
+        },
+    };
+}
+// Internal: properly typed for recast builder compatibility
+function createObj(props = []) {
+    return {
+        prop(key, value) {
+            const newProp = b.objectProperty(b.identifier(key), toExpr(value));
+            return createObj([...props, newProp]);
+        },
+        stringProp(key, value) {
+            const newProp = b.objectProperty(b.stringLiteral(key), toExpr(value));
+            return createObj([...props, newProp]);
+        },
+        computed(key, value) {
+            const prop = b.objectProperty(toExpr(key), toExpr(value));
+            prop.computed = true;
+            return createObj([...props, prop]);
+        },
+        spread(expr) {
+            const spreadElem = b.spreadElement(toExpr(expr));
+            return createObj([...props, spreadElem]);
+        },
+        shorthand(key) {
+            const prop = b.objectProperty(b.identifier(key), b.identifier(key));
+            prop.shorthand = true;
+            return createObj([...props, prop]);
+        },
+        build() {
+            return b.objectExpression(props);
+        },
+    };
+}
+// Internal: properly typed for recast builder compatibility
+function createArr(elems = []) {
+    return {
+        add(...exprs) {
+            const newElems = exprs.map((e) => toExpr(e));
+            return createArr([...elems, ...newElems]);
+        },
+        spread(expr) {
+            const spreadElem = b.spreadElement(toExpr(expr));
+            return createArr([...elems, spreadElem]);
+        },
+        build() {
+            return b.arrayExpression(elems);
+        },
+    };
+}
+const defaultParam = (name, type) => ({
+    name,
+    type,
+    optional: false,
+    rest: false,
+    defaultValue: undefined,
+});
+function createFn(config) {
+    const buildParams = () => config.params.map((p) => {
+        if (p.rest) {
+            const restId = b.identifier(p.name);
+            if (p.type) {
+                restId.typeAnnotation = b.tsTypeAnnotation(toTSType(p.type));
+            }
+            return b.restElement(restId);
+        }
+        else if (p.defaultValue) {
+            // For default params, type annotation goes on the identifier
+            const id = b.identifier(p.name);
+            if (p.type) {
+                id.typeAnnotation = b.tsTypeAnnotation(toTSType(p.type));
+            }
+            return b.assignmentPattern(id, toExpr(p.defaultValue));
+        }
+        else {
+            const param = b.identifier(p.name);
+            if (p.type) {
+                param.typeAnnotation = b.tsTypeAnnotation(toTSType(p.type));
+            }
+            if (p.optional) {
+                param.optional = true;
+            }
+            return param;
+        }
+    });
+    return {
+        param(name, type) {
+            return createFn({
+                ...config,
+                params: [...config.params, defaultParam(name, type)],
+            });
+        },
+        optionalParam(name, type) {
+            return createFn({
+                ...config,
+                params: [...config.params, { ...defaultParam(name, type), optional: true }],
+            });
+        },
+        restParam(name, type) {
+            return createFn({
+                ...config,
+                params: [...config.params, { ...defaultParam(name, type), rest: true }],
+            });
+        },
+        defaultParam(name, defaultValue, type) {
+            return createFn({
+                ...config,
+                params: [...config.params, { ...defaultParam(name, type), defaultValue }],
+            });
+        },
+        returns(type) {
+            return createFn({ ...config, returnType: type });
+        },
+        body(...statements) {
+            return createFn({ ...config, body: statements });
+        },
+        async() {
+            return createFn({ ...config, isAsync: true });
+        },
+        arrow() {
+            return createFn({ ...config, isArrow: true });
+        },
+        generator() {
+            return createFn({ ...config, isGenerator: true });
+        },
+        build() {
+            const params = buildParams();
+            const block = b.blockStatement(config.body.map(toStmt));
+            if (config.isArrow) {
+                const fn = b.arrowFunctionExpression(params, block, false);
+                fn.async = config.isAsync;
+                if (config.returnType) {
+                    fn.returnType = b.tsTypeAnnotation(toTSType(config.returnType));
+                }
+                return fn;
+            }
+            else {
+                const fn = b.functionExpression(null, params, block, config.isGenerator);
+                fn.async = config.isAsync;
+                if (config.returnType) {
+                    fn.returnType = b.tsTypeAnnotation(toTSType(config.returnType));
+                }
+                return fn;
+            }
+        },
+        toDeclaration(name) {
+            const params = buildParams();
+            const block = b.blockStatement(config.body.map(toStmt));
+            const fn = b.functionDeclaration(b.identifier(name), params, block, config.isGenerator);
+            fn.async = config.isAsync;
+            if (config.returnType) {
+                fn.returnType = b.tsTypeAnnotation(toTSType(config.returnType));
+            }
+            return fn;
+        },
+    };
+}
+/**
+ * Operator helpers for building expressions.
+ */
+const op = {
+    /** Generic binary expression */
+    binary: (left, operator, right) => b.binaryExpression(operator, toExpr(left), toExpr(right)),
+    /** Logical expression (&&, ||, ??) */
+    logical: (left, operator, right) => b.logicalExpression(operator, toExpr(left), toExpr(right)),
+    /** Unary expression */
+    unary: (operator, argument) => b.unaryExpression(operator, toExpr(argument)),
+    /** Assignment expression */
+    assign: (left, operator, right) => b.assignmentExpression(operator, left, toExpr(right)),
+    /** Ternary/conditional expression */
+    ternary: (test, consequent, alternate) => b.conditionalExpression(toExpr(test), toExpr(consequent), toExpr(alternate)),
+    /** New expression */
+    new: (callee, args = []) => b.newExpression(toExpr(callee), args.map(toExpr)),
+    // Common shortcuts
+    /** Strict equality: `===` */
+    eq: (left, right) => b.binaryExpression("===", toExpr(left), toExpr(right)),
+    /** Strict inequality: `!==` */
+    neq: (left, right) => b.binaryExpression("!==", toExpr(left), toExpr(right)),
+    /** Logical not: `!` */
+    not: (expr) => b.unaryExpression("!", toExpr(expr)),
+    /** Logical and: `&&` */
+    and: (left, right) => b.logicalExpression("&&", toExpr(left), toExpr(right)),
+    /** Logical or: `||` */
+    or: (left, right) => b.logicalExpression("||", toExpr(left), toExpr(right)),
+    /** Nullish coalescing: `??` */
+    nullish: (left, right) => b.logicalExpression("??", toExpr(left), toExpr(right)),
+};
+// =============================================================================
+// Statement Helpers
+// =============================================================================
+/**
+ * Statement builders.
+ */
+const stmt = {
+    /** `const name = init` */
+    const: (name, init, type) => {
+        const id = b.identifier(name);
+        if (type) {
+            id.typeAnnotation = b.tsTypeAnnotation(toTSType(type));
+        }
+        return b.variableDeclaration("const", [b.variableDeclarator(id, toExpr(init))]);
+    },
+    /** `let name = init` */
+    let: (name, init, type) => {
+        const id = b.identifier(name);
+        if (type) {
+            id.typeAnnotation = b.tsTypeAnnotation(toTSType(type));
+        }
+        return b.variableDeclaration("let", [
+            b.variableDeclarator(id, init ? toExpr(init) : null),
+        ]);
+    },
+    /** `return expr` */
+    return: (expr) => expr ? b.returnStatement(toExpr(expr)) : b.returnStatement(null),
+    /** Expression statement: `expr;` */
+    expr: (expr) => b.expressionStatement(toExpr(expr)),
+    /** If statement */
+    if: (test, consequent, alternate) => b.ifStatement(toExpr(test), b.blockStatement(consequent.map(toStmt)), alternate ? b.blockStatement(alternate.map(toStmt)) : null),
+    /** Throw statement */
+    throw: (expr) => b.throwStatement(toExpr(expr)),
+    /** Try-catch statement */
+    try: (block, catchParam, catchBlock, finallyBlock) => b.tryStatement(b.blockStatement(block.map(toStmt)), b.catchClause(b.identifier(catchParam), null, b.blockStatement(catchBlock.map(toStmt))), finallyBlock ? b.blockStatement(finallyBlock.map(toStmt)) : null),
+    /** For...of statement */
+    forOf: (varKind, varName, iterable, body) => b.forOfStatement(b.variableDeclaration(varKind, [
+        b.variableDeclarator(b.identifier(varName)),
+    ]), toExpr(iterable), b.blockStatement(body.map(toStmt))),
+    /** Block statement */
+    block: (...statements) => b.blockStatement(statements.map(toStmt)),
+};
+// =============================================================================
+// TypeScript Type Helpers
+// =============================================================================
+/**
+ * TypeScript type node builders.
+ */
+const ts = {
+    // Keyword types
+    string: () => b.tsStringKeyword(),
+    number: () => b.tsNumberKeyword(),
+    boolean: () => b.tsBooleanKeyword(),
+    bigint: () => b.tsBigIntKeyword(),
+    any: () => b.tsAnyKeyword(),
+    unknown: () => b.tsUnknownKeyword(),
+    never: () => b.tsNeverKeyword(),
+    void: () => b.tsVoidKeyword(),
+    null: () => b.tsNullKeyword(),
+    undefined: () => b.tsUndefinedKeyword(),
+    /** Type reference: `TypeName` or `TypeName<T>` */
+    ref: (name, typeParams) => {
+        const ref = b.tsTypeReference(b.identifier(name));
+        if (typeParams && typeParams.length > 0) {
+            ref.typeParameters = b.tsTypeParameterInstantiation(typeParams.map(toTSType));
+        }
+        return ref;
+    },
+    /** Qualified name reference: `Namespace.Type` */
+    qualifiedRef: (qualifier, name, typeParams) => {
+        const ref = b.tsTypeReference(b.tsQualifiedName(b.identifier(qualifier), b.identifier(name)));
+        if (typeParams && typeParams.length > 0) {
+            ref.typeParameters = b.tsTypeParameterInstantiation(typeParams.map(toTSType));
+        }
+        return ref;
+    },
+    /** Array type: `T[]` */
+    array: (elementType) => b.tsArrayType(toTSType(elementType)),
+    /** Union type: `A | B | C` */
+    union: (...types) => b.tsUnionType(types.map(toTSType)),
+    /** Intersection type: `A & B` */
+    intersection: (...types) => b.tsIntersectionType(types.map(toTSType)),
+    /** Literal type: `"value"` or `42` */
+    literal: (value) => {
+        if (typeof value === "string") {
+            return b.tsLiteralType(b.stringLiteral(value));
+        }
+        else if (typeof value === "number") {
+            return b.tsLiteralType(b.numericLiteral(value));
+        }
+        else {
+            return b.tsLiteralType(b.booleanLiteral(value));
+        }
+    },
+    /** Tuple type: `[A, B, C]` */
+    tuple: (...types) => b.tsTupleType(types.map(toTSType)),
+    /** Function type: `(a: A, b: B) => R` */
+    fn: (params, returnType) => {
+        const fnParams = params.map((p) => {
+            const param = b.identifier(p.name);
+            param.typeAnnotation = b.tsTypeAnnotation(toTSType(p.type));
+            if (p.optional) {
+                param.optional = true;
+            }
+            return param;
+        });
+        const fnType = b.tsFunctionType(fnParams);
+        fnType.typeAnnotation = b.tsTypeAnnotation(toTSType(returnType));
+        return fnType;
+    },
+    /** Typeof type: `typeof x` */
+    typeof: (expr) => b.tsTypeQuery(b.identifier(expr)),
+    /** Keyof type: `keyof T` */
+    keyof: (type) => ({
+        type: "TSTypeOperator",
+        operator: "keyof",
+        typeAnnotation: toTSType(type),
+    }),
+    /** Readonly type: `readonly T` */
+    readonly: (type) => ({
+        type: "TSTypeOperator",
+        operator: "readonly",
+        typeAnnotation: toTSType(type),
+    }),
+    /** Promise type: `Promise<T>` */
+    promise: (inner) => b.tsTypeReference(b.identifier("Promise"), b.tsTypeParameterInstantiation([toTSType(inner)])),
+    /**
+     * Object type literal: `{ name: string; age?: number }`
+     * @example
+     * ts.objectType([
+     *   { name: "id", type: ts.string() },
+     *   { name: "count", type: ts.number(), optional: true },
+     * ])
+     */
+    objectType: (props) => b.tsTypeLiteral(props.map(p => {
+        const sig = b.tsPropertySignature(b.identifier(p.name), b.tsTypeAnnotation(toTSType(p.type)));
+        if (p.optional)
+            sig.optional = true;
+        if (p.readonly)
+            sig.readonly = true;
+        return sig;
+    })),
+};
+/**
+ * Parameter builders for function signatures.
+ */
+const param = {
+    /**
+     * Create a typed parameter: `name: Type`
+     */
+    typed: (name, type) => {
+        const id = b.identifier(name);
+        id.typeAnnotation = b.tsTypeAnnotation(toTSType(type));
+        return id;
+    },
+    /**
+     * Create an optional typed parameter: `name?: Type`
+     */
+    optional: (name, type) => {
+        const id = b.identifier(name);
+        id.typeAnnotation = b.tsTypeAnnotation(toTSType(type));
+        id.optional = true;
+        return id;
+    },
+    /**
+     * Create a parameter with default value: `name: Type = defaultValue`
+     */
+    withDefault: (name, defaultValue, type) => {
+        const id = b.identifier(name);
+        if (type) {
+            id.typeAnnotation = b.tsTypeAnnotation(toTSType(type));
+        }
+        return b.assignmentPattern(id, toExpr(defaultValue));
+    },
+    /**
+     * Create a destructured parameter with Pick type: `{ field }: Pick<Entity, 'field'>`
+     *
+     * @example
+     * param.pick(["id", "name"], "UserRow")
+     * // { id, name }: Pick<UserRow, "id" | "name">
+     */
+    pick: (fields, entityType) => {
+        const pattern = b.objectPattern(fields.map((f) => {
+            const prop = b.objectProperty(b.identifier(f), b.identifier(f));
+            prop.shorthand = true;
+            return prop;
+        }));
+        // Pick<Entity, 'field1' | 'field2'>
+        const pickType = ts.ref("Pick", [
+            ts.ref(entityType),
+            fields.length === 1
+                ? ts.literal(fields[0])
+                : ts.union(...fields.map((f) => ts.literal(f))),
+        ]);
+        pattern.typeAnnotation = b.tsTypeAnnotation(toTSType(pickType));
+        return pattern;
+    },
+    /**
+     * Create a destructured parameter with explicit types and optional defaults.
+     *
+     * @example
+     * param.destructured([
+     *   { name: "limit", type: ts.number(), optional: true, defaultValue: conjure.num(50) },
+     *   { name: "offset", type: ts.number(), optional: true, defaultValue: conjure.num(0) },
+     * ])
+     * // { limit = 50, offset = 0 }: { limit?: number; offset?: number }
+     */
+    destructured: (fields) => {
+        const pattern = b.objectPattern(fields.map((f) => {
+            const id = b.identifier(f.name);
+            // Use AssignmentPattern for default values: { limit = 50 }
+            const value = f.defaultValue
+                ? b.assignmentPattern(id, toExpr(f.defaultValue))
+                : id;
+            const prop = b.objectProperty(b.identifier(f.name), value);
+            prop.shorthand = true;
+            return prop;
+        }));
+        // Build the type annotation: { name: type; name?: type; }
+        const typeAnnotation = ts.objectType(fields.map((f) => ({ name: f.name, type: f.type, optional: f.optional })));
+        pattern.typeAnnotation = b.tsTypeAnnotation(toTSType(typeAnnotation));
+        return pattern;
+    },
+};
+// =============================================================================
+// Export Helpers (exp.*)
+// =============================================================================
+/**
+ * Helper to create a SymbolStatement wrapper
+ */
+function symbolStatement(node, symbol) {
+    return { _tag: "SymbolStatement", node, symbol };
+}
+/**
+ * Helper to create SymbolMeta with proper handling of optional shape
+ */
+function createSymbolMeta(name, ctx, isType) {
+    const base = {
+        name,
+        capability: ctx.capability,
+        entity: ctx.entity,
+        isType,
+    };
+    return ctx.shape !== undefined ? { ...base, shape: ctx.shape } : base;
+}
+/**
+ * Build interface properties from property signature objects
+ */
+function buildInterfaceProperties(props) {
+    return props.map((p) => {
+        const sig = b.tsPropertySignature(b.identifier(p.name), b.tsTypeAnnotation(toTSType(p.type)));
+        if (p.optional)
+            sig.optional = true;
+        if (p.readonly)
+            sig.readonly = true;
+        return sig;
+    });
+}
+/**
+ * Export helpers that produce statements with symbol metadata.
+ * These are used for tracking exports across files for import resolution.
+ */
+export const exp = {
+    /**
+     * Export interface declaration: `export interface Name { ... }`
+     */
+    interface: (name, ctx, properties) => {
+        const decl = b.tsInterfaceDeclaration(b.identifier(name), b.tsInterfaceBody(buildInterfaceProperties(properties)));
+        const exportDecl = b.exportNamedDeclaration(decl, []);
+        return symbolStatement(exportDecl, createSymbolMeta(name, ctx, true));
+    },
+    /**
+     * Export type alias: `export type Name = Type`
+     */
+    typeAlias: (name, ctx, type) => {
+        const decl = b.tsTypeAliasDeclaration(b.identifier(name), toTSType(type));
+        const exportDecl = b.exportNamedDeclaration(decl, []);
+        return symbolStatement(exportDecl, createSymbolMeta(name, ctx, true));
+    },
+    /**
+     * Export const declaration: `export const name = init`
+     */
+    const: (name, ctx, init, typeAnnotation) => {
+        const id = b.identifier(name);
+        if (typeAnnotation) {
+            id.typeAnnotation = b.tsTypeAnnotation(toTSType(typeAnnotation));
+        }
+        const decl = b.variableDeclaration("const", [
+            b.variableDeclarator(id, toExpr(init)),
+        ]);
+        const exportDecl = b.exportNamedDeclaration(decl, []);
+        return symbolStatement(exportDecl, createSymbolMeta(name, ctx, false));
+    },
+    /**
+     * Export type alias for inferred types: `export type Name = typeof schema`
+     * Useful for exporting the inferred type alongside a schema constant.
+     */
+    type: (name, ctx, type) => {
+        // This is the same as typeAlias but semantically distinct -
+        // used for inferred types like `z.infer<typeof Schema>`
+        const decl = b.tsTypeAliasDeclaration(b.identifier(name), toTSType(type));
+        const exportDecl = b.exportNamedDeclaration(decl, []);
+        return symbolStatement(exportDecl, createSymbolMeta(name, ctx, true));
+    },
+};
+// =============================================================================
+// Program Builder
+// =============================================================================
+/**
+ * Type guard for SymbolStatement
+ */
+function isSymbolStatement(stmt) {
+    return (typeof stmt === "object" &&
+        stmt !== null &&
+        "_tag" in stmt &&
+        stmt._tag === "SymbolStatement");
+}
+/**
+ * Create a SymbolProgram from statements, extracting symbol metadata.
+ * Accepts both regular statements and SymbolStatements.
+ */
+function createSymbolProgram(...statements) {
+    const nodes = [];
+    const symbols = [];
+    for (const stmt of statements) {
+        if (isSymbolStatement(stmt)) {
+            nodes.push(stmt.node);
+            symbols.push(stmt.symbol);
+        }
+        else {
+            nodes.push(stmt);
+        }
+    }
+    return {
+        _tag: "SymbolProgram",
+        node: b.program(nodes.map(toStmt)),
+        symbols,
+    };
+}
+// =============================================================================
+// Main API
+// =============================================================================
+/**
+ * Conjure - AST Builder DSL
+ *
+ * A fluent, immutable API for constructing JavaScript/TypeScript AST nodes.
+ */
+export const conjure = {
+    // === Chain builders ===
+    /** Start a chain from an identifier */
+    id: (name) => createChain(b.identifier(name)),
+    /** Start a chain from any expression */
+    chain: (expr) => createChain(expr),
+    // === Compound builders ===
+    /** Start an object literal builder */
+    obj: () => createObj(),
+    /** Start an array literal builder */
+    arr: (...elements) => createArr(elements.map((e) => toExpr(e))),
+    /** Start a function builder */
+    fn: () => createFn({
+        params: [],
+        body: [],
+        returnType: null,
+        isAsync: false,
+        isArrow: false,
+        isGenerator: false,
+    }),
+    // === Literals ===
+    /** String literal */
+    str: (value) => b.stringLiteral(value),
+    /** Numeric literal */
+    num: (value) => b.numericLiteral(value),
+    /** Boolean literal */
+    bool: (value) => b.booleanLiteral(value),
+    /** null */
+    null: () => b.nullLiteral(),
+    /** undefined */
+    undefined: () => b.identifier("undefined"),
+    /** Template literal */
+    template: (quasis, ...expressions) => {
+        const templateElements = quasis.map((raw, i) => b.templateElement({ raw, cooked: raw }, i === quasis.length - 1));
+        return b.templateLiteral(templateElements, expressions.map(toExpr));
+    },
+    // === Operators ===
+    op,
+    // === Statements ===
+    stmt,
+    // === TypeScript types ===
+    ts,
+    // === Parameter helpers ===
+    param,
+    // === Export helpers ===
+    exp,
+    // === Helpers ===
+    /** Await expression */
+    await: (expr) => b.awaitExpression(toExpr(expr)),
+    /** Spread expression (for use in arrays/calls) */
+    spread: (expr) => b.spreadElement(toExpr(expr)),
+    /** Print AST node to code string */
+    print: (node) => recast.print(node).code,
+    /** Create a program from statements (backwards compatible) */
+    program: (...statements) => b.program(statements.map(toStmt)),
+    /**
+     * Create a SymbolProgram from statements, extracting symbol metadata.
+     * Accepts both regular statements and SymbolStatements.
+     * Returns a SymbolProgram with the AST node and extracted symbols.
+     */
+    symbolProgram: createSymbolProgram,
+    // === Raw builders (escape hatch) ===
+    /** Raw recast builders for advanced use cases */
+    b,
+};
+export default conjure;
+//# sourceMappingURL=conjure.js.map