@syncular/typegen 0.2.0 → 0.3.0

package/dist/emit.js

@@ -1,3 +1,4 @@
+import { snakeToCamel } from './naming.js';
 const TS_TYPE = {
     string: 'string',
     integer: 'number',
@@ -82,14 +83,18 @@ function emitSchema(ir) {
     lines.push('} as const;');
     return lines.join('\n');
 }
-function emitRowInterfaces(table) {
+function emitRowInterfaces(table, naming) {
     const type = pascalCase(table.name);
+    // §5: mutation-input/row keys are the language-facing names; `mutate`
+    // normalizes them back through the schema naming map (camel or snake both
+    // bind — one map lookup per key).
+    const key = (name) => propertyKey(naming === 'camel' ? snakeToCamel(name) : name);
     const lines = [];
     lines.push(`/** One ${table.name} row (§2.4 column order). */`);
     lines.push(`export interface ${type}Row {`);
     for (const column of table.columns) {
         const ts = appTsType(column);
-        lines.push(`  ${propertyKey(column.name)}: ${ts}${column.nullable ? ' | null' : ''};`);
+        lines.push(`  ${key(column.name)}: ${ts}${column.nullable ? ' | null' : ''};`);
     }
     lines.push('}');
     lines.push('');
@@ -98,8 +103,8 @@ function emitRowInterfaces(table) {
     for (const column of table.columns) {
         const ts = appTsType(column);
         lines.push(column.nullable
-            ? `  ${propertyKey(column.name)}?: ${ts} | null;`
-            : `  ${propertyKey(column.name)}: ${ts};`);
+            ? `  ${key(column.name)}?: ${ts} | null;`
+            : `  ${key(column.name)}: ${ts};`);
     }
     lines.push('}');
     lines.push('');
@@ -108,33 +113,15 @@ function emitRowInterfaces(table) {
     for (const column of table.columns) {
         const ts = appTsType(column);
         if (column.name === table.primaryKey) {
-            lines.push(`  ${propertyKey(column.name)}: ${ts};`);
+            lines.push(`  ${key(column.name)}: ${ts};`);
         }
         else {
-            lines.push(`  ${propertyKey(column.name)}?: ${ts}${column.nullable ? ' | null' : ''};`);
+            lines.push(`  ${key(column.name)}?: ${ts}${column.nullable ? ' | null' : ''};`);
         }
     }
     lines.push('}');
     return lines.join('\n');
 }
-/**
- * A Kysely-compatible `Database` interface: table name → Row type. This is
- * the generic `@syncular/kysely`'s `SyncularDialect` is parameterized by
- * (`new Kysely<Database>({ dialect })`). Additive — the Row interfaces it
- * references are already emitted above. Property keys use the raw table name
- * (quoted when not an identifier) so `db.selectFrom('table-name')` types.
- */
-function emitDatabaseInterface(ir) {
-    const lines = [];
-    lines.push('/** Kysely `Database` interface (table → Row); the generic for');
-    lines.push(" *  @syncular/kysely's SyncularDialect. */");
-    lines.push('export interface Database {');
-    for (const table of ir.tables) {
-        lines.push(`  ${propertyKey(table.name)}: ${pascalCase(table.name)}Row;`);
-    }
-    lines.push('}');
-    return lines.join('\n');
-}
 function emitSubscription(sub) {
     const params = [];
     for (const scope of sub.scopes) {
@@ -172,7 +159,7 @@ function emitSubscription(sub) {
     lines.push('} as const;');
     return lines.join('\n');
 }
-export function emitModule(ir, hash) {
+export function emitModule(ir, hash, naming = 'camel') {
     const parts = [];
     parts.push([
         '// Generated by @syncular/typegen — DO NOT EDIT.',
@@ -181,9 +168,8 @@ export function emitModule(ir, hash) {
     ].join('\n'));
     parts.push(emitSchema(ir));
     for (const table of ir.tables) {
-        parts.push(emitRowInterfaces(table));
+        parts.push(emitRowInterfaces(table, naming));
     }
-    parts.push(emitDatabaseInterface(ir));
     for (const sub of ir.subscriptions) {
         parts.push(emitSubscription(sub));
     }

package/dist/fmt.d.ts

@@ -0,0 +1,3 @@
+/** Format one `.syql` source file into its canonical form. Throws
+ * {@link TypegenError} when the source does not parse. */
+export declare function formatSyql(file: string, source: string): string;

package/dist/fmt.js

@@ -0,0 +1,356 @@
+/**
+ * `syncular fmt` — the canonical `.syql` formatter (DESIGN-queries.md §10,
+ * §12). One style, no options:
+ *
+ * - SQL keywords lowercase; identifier casing preserved (SQL-truth).
+ * - one space after commas; collapsed whitespace elsewhere.
+ * - one clause per line in the body; WHERE conjuncts one per line,
+ *   `and`-prefixed and indented under the `where`.
+ * - declarations separated by one blank line; knobs on their own lines.
+ * - comments are preserved: a declaration's leading comment block stays
+ *   above it; comments inside bodies stay on their own lines.
+ *
+ * The formatter is built on the same parser as the generator (`.syql` that
+ * does not parse does not format), and formatting is semantics-preserving
+ * by construction — `fmt` output re-parses to the same declarations.
+ */
+import { TypegenError } from './errors.js';
+import { parseSyqlFile } from './syql.js';
+/** SQL keywords the canon lowercases (a pragmatic core set — identifiers
+ * that collide with these would need quoting anyway). */
+const SQL_KEYWORDS = new Set(('select from where group by having order limit offset window and or not ' +
+    'in is null like glob between exists case when then else end as on using ' +
+    'join left right full outer inner cross natural union all except ' +
+    'intersect distinct values with recursive asc desc collate cast').split(' '));
+/** Tokenize a body: strings/comments verbatim, words, `:params`,
+ * `@fragment` refs, single punctuation chars. */
+function tokenize(body) {
+    const tokens = [];
+    let i = 0;
+    while (i < body.length) {
+        const ch = body[i];
+        if (/\s/.test(ch)) {
+            i += 1;
+            continue;
+        }
+        if (body.startsWith('--', i)) {
+            const nl = body.indexOf('\n', i);
+            const end = nl === -1 ? body.length : nl;
+            tokens.push({ kind: 'comment', text: body.slice(i, end).trimEnd() });
+            i = end;
+            continue;
+        }
+        if (body.startsWith('/*', i)) {
+            const close = body.indexOf('*/', i + 2);
+            const end = close === -1 ? body.length : close + 2;
+            tokens.push({ kind: 'comment', text: body.slice(i, end) });
+            i = end;
+            continue;
+        }
+        if (ch === "'") {
+            let j = i + 1;
+            for (;;) {
+                if (j >= body.length)
+                    break;
+                if (body[j] === "'") {
+                    if (body[j + 1] === "'")
+                        j += 2;
+                    else {
+                        j += 1;
+                        break;
+                    }
+                }
+                else
+                    j += 1;
+            }
+            tokens.push({ kind: 'string', text: body.slice(i, j) });
+            i = j;
+            continue;
+        }
+        if (ch === ':' && /[A-Za-z_]/.test(body[i + 1] ?? '')) {
+            let j = i + 1;
+            while (j < body.length && /[A-Za-z0-9_]/.test(body[j]))
+                j += 1;
+            tokens.push({ kind: 'param', text: body.slice(i, j) });
+            i = j;
+            continue;
+        }
+        if (ch === '@' && /[A-Za-z_]/.test(body[i + 1] ?? '')) {
+            let j = i + 1;
+            while (j < body.length && /[A-Za-z0-9_]/.test(body[j]))
+                j += 1;
+            tokens.push({ kind: 'fragment', text: body.slice(i, j) });
+            i = j;
+            continue;
+        }
+        if (/[A-Za-z_]/.test(ch)) {
+            let j = i + 1;
+            while (j < body.length && /[A-Za-z0-9_]/.test(body[j]))
+                j += 1;
+            tokens.push({ kind: 'word', text: body.slice(i, j) });
+            i = j;
+            continue;
+        }
+        // Multi-char operators stay one token (`||`, `>=`, `<=`, `<>`, `!=`, `==`).
+        const two = body.slice(i, i + 2);
+        if (['||', '>=', '<=', '<>', '!=', '=='].includes(two)) {
+            tokens.push({ kind: 'punct', text: two });
+            i += 2;
+            continue;
+        }
+        tokens.push({ kind: 'punct', text: ch });
+        i += 1;
+    }
+    return tokens;
+}
+/** Render tokens back to one line with canonical spacing + keyword case. */
+function render(tokens) {
+    let out = '';
+    let prev;
+    for (const token of tokens) {
+        let text = token.text;
+        if (token.kind === 'word' && SQL_KEYWORDS.has(text.toLowerCase())) {
+            text = text.toLowerCase();
+        }
+        const glueLeft = token.kind === 'punct' &&
+            (text === ',' || text === ')' || text === ';' || text === '.');
+        const glueRight = prev !== undefined &&
+            ((prev.kind === 'punct' && (prev.text === '(' || prev.text === '.')) ||
+                prev.kind === 'fragment');
+        if (out.length > 0 && !glueLeft && !glueRight)
+            out += ' ';
+        out += text;
+        prev = token;
+    }
+    return out;
+}
+/** Clause keywords that start a new line at paren depth 0. */
+const CLAUSE_STARTERS = new Set([
+    'select',
+    'from',
+    'where',
+    'group',
+    'having',
+    'order',
+    'limit',
+    'window',
+    'union',
+    'except',
+    'intersect',
+]);
+/** Format a body: one clause per line; WHERE conjuncts one per line. */
+function formatBody(body) {
+    const tokens = tokenize(body);
+    const lines = [];
+    let current = [];
+    let depth = 0;
+    let braceDepth = 0;
+    let inWhere = false;
+    let pendingBetween = 0;
+    const flush = () => {
+        if (current.length > 0)
+            lines.push(render(current));
+        current = [];
+    };
+    for (const token of tokens) {
+        if (token.kind === 'comment') {
+            flush();
+            lines.push(token.text);
+            continue;
+        }
+        if (token.kind === 'punct') {
+            if (token.text === '(')
+                depth += 1;
+            else if (token.text === ')')
+                depth -= 1;
+            else if (token.text === '{')
+                braceDepth += 1;
+            else if (token.text === '}')
+                braceDepth -= 1;
+        }
+        if (token.kind === 'word' && depth === 0 && braceDepth === 0) {
+            const word = token.text.toLowerCase();
+            if (CLAUSE_STARTERS.has(word)) {
+                flush();
+                inWhere = word === 'where';
+                pendingBetween = 0;
+            }
+            else if (inWhere) {
+                if (word === 'between')
+                    pendingBetween += 1;
+                else if (word === 'and') {
+                    if (pendingBetween > 0)
+                        pendingBetween -= 1;
+                    else
+                        flush();
+                }
+            }
+        }
+        current.push(token);
+    }
+    flush();
+    // Indent: clauses flush-left; WHERE continuation (`and …`) indented 2.
+    return lines.map((line) => /^(and|or)\b/.test(line) || line.startsWith('--') ? `  ${line}` : line);
+}
+function formatSignature(decl) {
+    const parts = [];
+    const seenGroups = new Set();
+    for (const param of decl.params) {
+        if (param.group !== undefined) {
+            if (seenGroups.has(param.group))
+                continue;
+            seenGroups.add(param.group);
+            const members = decl.params.filter((p) => p.group === param.group);
+            parts.push(`${members.map((p) => p.name).join('+')}?`);
+            continue;
+        }
+        if (param.flag)
+            parts.push(`${param.name}?: flag`);
+        else
+            parts.push(`${param.name}${param.optional ? '?' : ''}`);
+    }
+    return parts.join(', ');
+}
+/** The leading comment block (verbatim lines) before each declaration. */
+function leadingComments(source) {
+    // Map from declaration index (0-based, in order of appearance) to its
+    // preceding comment lines.
+    const out = new Map();
+    let pending = [];
+    let declIndex = 0;
+    let i = 0;
+    while (i < source.length) {
+        const ch = source[i];
+        if (/\s/.test(ch)) {
+            i += 1;
+            continue;
+        }
+        if (source.startsWith('--', i)) {
+            const nl = source.indexOf('\n', i);
+            const end = nl === -1 ? source.length : nl;
+            pending.push(source.slice(i, end).trimEnd());
+            i = end;
+            continue;
+        }
+        if (source.startsWith('/*', i)) {
+            const close = source.indexOf('*/', i + 2);
+            const end = close === -1 ? source.length : close + 2;
+            pending.push(source.slice(i, end));
+            i = end;
+            continue;
+        }
+        // A declaration keyword: attach pending comments, then skip through its
+        // brace block.
+        if (pending.length > 0) {
+            out.set(declIndex, pending);
+            pending = [];
+        }
+        declIndex += 1;
+        const brace = source.indexOf('{', i);
+        if (brace === -1)
+            break;
+        let depth = 0;
+        let j = brace;
+        while (j < source.length) {
+            const c = source[j];
+            if (c === "'") {
+                j += 1;
+                while (j < source.length && source[j] !== "'")
+                    j += 1;
+            }
+            else if (source.startsWith('--', j)) {
+                const nl = source.indexOf('\n', j);
+                j = nl === -1 ? source.length : nl;
+            }
+            else if (c === '{')
+                depth += 1;
+            else if (c === '}') {
+                depth -= 1;
+                if (depth === 0) {
+                    j += 1;
+                    break;
+                }
+            }
+            j += 1;
+        }
+        i = j;
+    }
+    return out;
+}
+/** Format one `.syql` source file into its canonical form. Throws
+ * {@link TypegenError} when the source does not parse. */
+export function formatSyql(file, source) {
+    const parsed = parseSyqlFile(file, source);
+    const comments = leadingComments(source);
+    const decls = [];
+    // Re-derive declaration order (fragments/queries interleave in-source);
+    // parseSyqlFile keeps per-kind order, so re-scan the source for kind
+    // keywords to interleave faithfully.
+    const orderRe = /\b(query|fragment)\s+([A-Za-z][A-Za-z0-9]*)/g;
+    const blanked = source
+        .replace(/--[^\n]*/g, (m) => ' '.repeat(m.length))
+        .replace(/\/\*[\s\S]*?\*\//g, (m) => ' '.repeat(m.length))
+        .replace(/'(?:[^']|'')*'/g, (m) => ' '.repeat(m.length));
+    const sequence = [];
+    let braceDepth = 0;
+    let lastIndex = 0;
+    for (let i = 0; i < blanked.length; i++) {
+        const c = blanked[i];
+        if (c === '{')
+            braceDepth += 1;
+        else if (c === '}')
+            braceDepth -= 1;
+        else if (braceDepth === 0) {
+            orderRe.lastIndex = i;
+            const m = orderRe.exec(blanked);
+            if (m !== null && m.index === i) {
+                sequence.push({ kind: m[1], name: m[2] });
+                i = orderRe.lastIndex - 1;
+                lastIndex = orderRe.lastIndex;
+            }
+        }
+    }
+    void lastIndex;
+    sequence.forEach((entry, index) => {
+        const lines = [];
+        const leading = comments.get(index);
+        if (leading !== undefined)
+            lines.push(...leading);
+        if (entry.kind === 'fragment') {
+            const decl = parsed.fragments.find((f) => f.name === entry.name);
+            if (decl === undefined)
+                return;
+            lines.push(`fragment ${decl.name}(${formatSignature(decl)}) {`);
+            for (const line of formatBody(decl.body))
+                lines.push(`  ${line}`);
+            lines.push('}');
+        }
+        else {
+            const decl = parsed.queries.find((q) => q.name === entry.name);
+            if (decl === undefined)
+                return;
+            const knobs = [];
+            if (decl.orderBy !== undefined) {
+                const dir = decl.orderBy.defaultDir === 'desc' ? ' desc' : '';
+                knobs.push(`  orderBy ${decl.orderBy.allowed.join(' | ')} default ${decl.orderBy.defaultColumn}${dir}`);
+            }
+            if (decl.limit !== undefined) {
+                const parts = [];
+                if (decl.limit.max !== undefined)
+                    parts.push(`max ${decl.limit.max}`);
+                if (decl.limit.default !== undefined) {
+                    parts.push(`default ${decl.limit.default}`);
+                }
+                knobs.push(`  limit ${parts.join(' ')}`);
+            }
+            if (decl.variants === true)
+                knobs.push('  variants');
+            lines.push(`query ${decl.name}(${formatSignature(decl)})${knobs.length > 0 ? `\n${knobs.join('\n')}\n{` : ' {'}`);
+            for (const line of formatBody(decl.body))
+                lines.push(`  ${line}`);
+            lines.push('}');
+        }
+        decls.push({ order: index, text: lines.join('\n') });
+    });
+    return `${decls.map((d) => d.text).join('\n\n')}\n`;
+}

package/dist/generate.d.ts

@@ -4,7 +4,7 @@
  */
 import { type IrDocument } from './ir.js';
 import { type Manifest } from './manifest.js';
-import { type AnalyzedQuery } from './query.js';
+import { type AnalyzedQuery, type QueryDb, type QueryNamingOptions } from './query.js';
 export interface MigrationInput {
     /** Directory name, e.g. `0001_initial`. */
     readonly name: string;
@@ -15,19 +15,29 @@ export interface MigrationInput {
 export declare function buildIr(manifest: Manifest, migrations: readonly MigrationInput[]): IrDocument;
 /** Load `NNNN_name/up.sql` migrations, ordered by numeric prefix. */
 export declare function loadMigrations(migrationsDir: string): MigrationInput[];
-/** One `.sql` named-query file: path (relative to the queries root, forward
- * slashes) + raw contents. A file may hold multiple statements. */
+/** One named-query file (`.sql` — the compatibility floor — or `.syql`, the
+ * DSL): path relative to the queries root (forward slashes) + raw contents.
+ * A file may hold multiple statements/declarations. */
 export interface QueryInput {
     /** Path relative to the queries root, forward-slashed (e.g.
-     * `billing/invoices/list.sql`). Drives the path-derived default name. */
+     * `billing/invoices/list.sql`). Drives the path-derived default name for
+     * `.sql`; `.syql` queries carry their own names. */
     readonly file: string;
     readonly sql: string;
 }
-/** Load `queries/**\/*.sql` recursively, ordered by relative path
+/** Load `queries/**\/*.{sql,syql}` recursively, ordered by relative path
  * (deterministic emission). Folders are pure organization. */
 export declare function loadQueries(queriesDir: string): QueryInput[];
+/** A {@link QueryDb} backed by an in-memory bun:sqlite built from the IR DDL.
+ * `analyze` prepares the statement (validating references) and reads its
+ * column names + declared types; it executes once against the empty DB so
+ * `declaredTypes` (decltype) is populated. */
+export declare function makeQueryDb(ir: IrDocument): {
+    db: QueryDb;
+    close: () => void;
+};
 /** Analyze every query file against the IR (SELECT-only, typed, deps). */
-export declare function analyzeQueries(ir: IrDocument, queries: readonly QueryInput[]): AnalyzedQuery[];
+export declare function analyzeQueries(ir: IrDocument, queries: readonly QueryInput[], naming?: QueryNamingOptions): AnalyzedQuery[];
 /** One generated artifact: an absolute output path and its exact bytes. */
 export interface GeneratedOutput {
     readonly path: string;

package/dist/generate.js

@@ -16,8 +16,10 @@ import { emitSwiftModule } from './emit-swift.js';
 import { TypegenError } from './errors.js';
 import { canonicalizeExtensions, IR_VERSION, irHash, serializeIr, } from './ir.js';
 import { MANIFEST_FILENAME, parseManifest, } from './manifest.js';
+import { buildNamingMap } from './naming.js';
 import { analyzeQueryFile, synthesizeDdl, } from './query.js';
 import { applyMigrationSql } from './sql.js';
+import { analyzeSyqlFile } from './syql.js';
 /** Same grammar the server compiles (§3.1): `prefix:{variable}`. */
 const PATTERN_RE = /^([^{}]+):\{([^{}:]+)\}$/;
 /** Whole-value placeholder: `{paramName}`. */
@@ -208,8 +210,8 @@ export function loadMigrations(migrationsDir) {
         return { name, sql: readFileSync(upPath, 'utf8') };
     });
 }
-/** Recursively collect `*.sql` paths under `dir`, relative to `root`
- * (forward-slashed), sorted for deterministic emission. */
+/** Recursively collect `*.sql` + `*.syql` paths under `dir`, relative to
+ * `root` (forward-slashed), sorted for deterministic emission. */
 function collectSqlFiles(root, dir) {
     const out = [];
     for (const entry of readdirSync(dir, { withFileTypes: true })) {
@@ -217,13 +219,14 @@ function collectSqlFiles(root, dir) {
         if (entry.isDirectory()) {
             out.push(...collectSqlFiles(root, abs));
         }
-        else if (entry.isFile() && entry.name.endsWith('.sql')) {
+        else if (entry.isFile() &&
+            (entry.name.endsWith('.sql') || entry.name.endsWith('.syql'))) {
             out.push(relative(root, abs).split(sep).join('/'));
         }
     }
     return out;
 }
-/** Load `queries/**\/*.sql` recursively, ordered by relative path
+/** Load `queries/**\/*.{sql,syql}` recursively, ordered by relative path
  * (deterministic emission). Folders are pure organization. */
 export function loadQueries(queriesDir) {
     if (!existsSync(queriesDir))
@@ -239,7 +242,7 @@ export function loadQueries(queriesDir) {
  * `analyze` prepares the statement (validating references) and reads its
  * column names + declared types; it executes once against the empty DB so
  * `declaredTypes` (decltype) is populated. */
-function makeQueryDb(ir) {
+export function makeQueryDb(ir) {
     const sqlite = new Database(':memory:');
     sqlite.run(synthesizeDdl(ir));
     const db = {
@@ -262,13 +265,17 @@ function makeQueryDb(ir) {
     return { db, close: () => sqlite.close() };
 }
 /** Analyze every query file against the IR (SELECT-only, typed, deps). */
-export function analyzeQueries(ir, queries) {
+export function analyzeQueries(ir, queries, naming) {
     if (queries.length === 0)
         return [];
     const { db, close } = makeQueryDb(ir);
     try {
         // Each file may hold multiple statements; flatten in path order (stable).
-        const analyzed = queries.flatMap((q) => analyzeQueryFile(q.file, q.sql, ir, db));
+        // Frontends dispatch on extension; both produce the same AnalyzedQuery
+        // shape (§1 — nothing downstream knows the frontend).
+        const analyzed = queries.flatMap((q) => q.file.endsWith('.syql')
+            ? analyzeSyqlFile(q.file, q.sql, ir, db, naming)
+            : analyzeQueryFile(q.file, q.sql, ir, db, naming));
         // Names must be unique across the whole manifest — the filesystem no longer
         // guarantees uniqueness once `-- name:` overrides exist. Report BOTH source
         // locations (file + statement position) on a collision.
@@ -302,9 +309,27 @@ export function generate(manifestDir) {
     const manifest = parseManifest(raw);
     const migrations = loadMigrations(resolve(manifestDir, manifest.migrations));
     const ir = buildIr(manifest, migrations);
+    // §5/§12 naming: the emitter targets this run generates (keyword hazards
+    // are only real on targets that exist), and the per-table collision check
+    // for the generated row types.
+    const targets = ['ts'];
+    if (manifest.output.swift !== undefined)
+        targets.push('swift');
+    if (manifest.output.kotlin !== undefined)
+        targets.push('kotlin');
+    if (manifest.output.dart !== undefined)
+        targets.push('dart');
+    const naming = {
+        naming: manifest.naming,
+        targets,
+        backend: manifest.queryBackend,
+    };
+    for (const table of ir.tables) {
+        buildNamingMap(table.columns.map((c) => c.name), manifest.naming, MANIFEST_FILENAME, `table ${table.name}`, targets);
+    }
     const irJson = serializeIr(ir);
     const hash = irHash(irJson);
-    const module = emitModule(ir, hash);
+    const module = emitModule(ir, hash, manifest.naming);
     const irPath = resolve(manifestDir, manifest.output.ir);
     const modulePath = resolve(manifestDir, manifest.output.module);
     const outputs = [
@@ -321,7 +346,7 @@ export function generate(manifestDir) {
         kotlin?.queriesPath !== undefined ||
         dart?.queriesPath !== undefined;
     const analyzedQueries = wantsQueries
-        ? analyzeQueries(ir, loadQueries(resolve(manifestDir, manifest.queries)))
+        ? analyzeQueries(ir, loadQueries(resolve(manifestDir, manifest.queries)), naming)
         : [];
     if (wantsQueries && analyzedQueries.length === 0) {
         throw new TypegenError(resolve(manifestDir, manifest.queries), `an output requests named queries but no .sql files were found in ${manifest.queries} — add a query file or drop the queries output`);

package/dist/index.d.ts

@@ -12,8 +12,14 @@ export * from './emit-queries-kotlin.js';
 export * from './emit-queries-swift.js';
 export * from './emit-swift.js';
 export * from './errors.js';
+export * from './fmt.js';
 export * from './generate.js';
 export * from './ir.js';
+export * from './lower.js';
+export * from './lsp.js';
 export * from './manifest.js';
+export * from './naming.js';
 export * from './query.js';
+export * from './query-ir.js';
 export * from './sql.js';
+export * from './syql.js';

package/dist/index.js

@@ -12,8 +12,14 @@ export * from './emit-queries-kotlin.js';
 export * from './emit-queries-swift.js';
 export * from './emit-swift.js';
 export * from './errors.js';
+export * from './fmt.js';
 export * from './generate.js';
 export * from './ir.js';
+export * from './lower.js';
+export * from './lsp.js';
 export * from './manifest.js';
+export * from './naming.js';
 export * from './query.js';
+export * from './query-ir.js';
 export * from './sql.js';
+export * from './syql.js';