@intentius/chant-lexicon-sql 0.124.31 → 0.124.33

package/dist/op/activities/postgres-emulator.js

@@ -0,0 +1,70 @@
+/**
+ * The sql lexicon's Postgres emulator capability (#3280): the official
+ * `postgres` image at the newest pin, by tag and digest (../../spec/postgres-pin.ts),
+ * the same server generation and the live tests run, so `chant emulator up`
+ * boots a real Postgres rather than a stand-in.
+ *
+ * Postgres has no HTTP health endpoint, so readiness is `pg_isready` run in
+ * the container against 127.0.0.1: the image's first, initdb-time server
+ * listens on its socket only, so the TCP check answers once the real server
+ * is up. The endpoint is a `postgres://` URL, which `POSTGRES_URL` carries;
+ * the user and password are `POSTGRES_USER` and `POSTGRES_PASSWORD`, the
+ * variables binding reads with it.
+ *
+ * `upstream` is left off: the pins move per major through the lexicon's
+ * `upstreamPins`, not the emulator freshness check.
+ */
+import { emulatorLifecycle } from "@intentius/chant/op";
+import { POSTGRES_LATEST_MAJOR, postgresImage } from "../../spec/postgres-pin.js";
+import { connectPostgres } from "../../postgres/live/client.js";
+/** The local server's password. It is a throwaway server on localhost. */
+export const POSTGRES_EMULATOR_PASSWORD = "chant";
+/** How long `chant emulator status` waits for the server behind the endpoint. */
+const PROBE_TIMEOUT_MS = 5000;
+/**
+ * The cluster's system identifier, unique per `initdb` (#3673): read in the
+ * container over its socket, and through the endpoint `status` prints. A
+ * native Postgres holding 127.0.0.1:5432 answers with its own, or refuses
+ * the emulator's sign-in.
+ */
+export const POSTGRES_EMULATOR_IDENTITY = {
+    server: "Postgres",
+    command: ["psql", "-U", "postgres", "-tAc", "select system_identifier from pg_control_system()"],
+    async probe(endpoint) {
+        const client = await withTimeout(connectPostgres({ url: endpoint, user: "postgres", password: POSTGRES_EMULATOR_PASSWORD }, { applicationName: "chant emulator status" }));
+        try {
+            const [row] = await withTimeout(client.query("SELECT system_identifier::text AS id, pg_catalog.current_setting('server_version') AS version FROM pg_catalog.pg_control_system()"));
+            return { id: row?.id ?? "", label: `PostgreSQL ${row?.version ?? "(unknown version)"}` };
+        }
+        finally {
+            await client.end();
+        }
+    },
+};
+function withTimeout(promise) {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`no answer within ${PROBE_TIMEOUT_MS / 1000}s`)), PROBE_TIMEOUT_MS);
+    });
+    return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}
+export const POSTGRES_EMULATOR_SPEC = {
+    name: "chant-postgres",
+    image: postgresImage(POSTGRES_LATEST_MAJOR),
+    containerPort: 5432,
+    readyCommand: ["pg_isready", "-h", "127.0.0.1", "-U", "postgres"],
+    endpoint: (port) => `postgres://localhost:${port}/postgres`,
+    runArgs: ["-e", `POSTGRES_PASSWORD=${POSTGRES_EMULATOR_PASSWORD}`],
+    identity: POSTGRES_EMULATOR_IDENTITY,
+    credentials: `user postgres, password ${POSTGRES_EMULATOR_PASSWORD}`,
+};
+/** `POSTGRES_URL` is the variable binding reads when no `sql.profiles.<env>` names a server. */
+export const POSTGRES_EMULATOR = {
+    spec: POSTGRES_EMULATOR_SPEC,
+    env: (endpoint) => ({ POSTGRES_URL: endpoint, POSTGRES_USER: "postgres", POSTGRES_PASSWORD: POSTGRES_EMULATOR_PASSWORD }),
+};
+const lifecycle = emulatorLifecycle(POSTGRES_EMULATOR_SPEC);
+/** Boot the pinned Postgres server in Docker and return its endpoint. */
+export const postgresUp = (args = {}, signal) => lifecycle.up(args, signal);
+/** Stop and remove it (a no-op when it is gone). */
+export const postgresDown = (args = {}, signal) => lifecycle.down(args, signal);

package/dist/op/activities/postgres-migration.js

@@ -0,0 +1,156 @@
+/**
+ * The expand-and-contract migration's activities (#3281), one per step of
+ * `PostgresMigrationOp` (`../../postgres/migrate/op.ts`). Each takes the same
+ * arguments, reads the build's declaration of the table and binds the
+ * environment's server the way the applier does (`./postgres-apply.ts`),
+ * opens one connection with node-postgres (loaded only now), runs its step
+ * (`../../postgres/migrate/`), which re-reads the server, and closes the
+ * connection.
+ */
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { currentOpRun, parseDuration } from "@intentius/chant/op";
+import { resolveOwnershipMarker } from "../../core/apply.js";
+import { resolveBoundTarget } from "../../postgres/live/bind.js";
+import { connectPostgres } from "../../postgres/live/client.js";
+import { DEFAULT_POSTGRES_APPLY_TIMEOUTS, declaredObjects } from "../../postgres/apply/apply.js";
+import { PG_CLASSIFIER_RULES } from "../../postgres/plan/rules.js";
+import { declaredTable, migrationPlanDigest, MigrationRefusal, observeMigration } from "../../postgres/migrate/observe.js";
+import { backfill, MigrationVerificationError, verifyMigration } from "../../postgres/migrate/backfill.js";
+import { carryOver, compensate, contract, expand, retainPlan, startDualWrite, switchColumns, } from "../../postgres/migrate/steps.js";
+import { DEFAULT_REPLICATION_LAG } from "../../postgres/migrate/replication.js";
+import { buildMajor } from "./postgres-apply.js";
+import { statementChange } from "../../core/statements.js";
+import { postgresMigrationPart } from "../../change-set.js";
+async function loadConfig(cwd) {
+    try {
+        const { loadChantConfig } = await import("@intentius/chant/config");
+        return (await loadChantConfig(cwd)).config;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * With `onFailure: "keep"` (#3687) no onFailure drops what the expand added,
+ * so a step that fails says what a person does instead: a refusal or a
+ * failed verification would otherwise fail every run after it the same way.
+ */
+const ON_FAILURE_DROPS = "onFailure drops what the expand added, and the next run starts again.";
+function noting(args, err) {
+    if (args.keepOnFailure && (err instanceof MigrationRefusal || err instanceof MigrationVerificationError)) {
+        const kept = `This migration keeps what the expand added on failure (onFailure: "keep"), so nothing drops it: ` +
+            `to start again from a new column, run the Op once with onFailure: "drop" (the default), whose onFailure drops it when this step fails again.`;
+        err.message = err.message.includes(ON_FAILURE_DROPS) ? err.message.replace(ON_FAILURE_DROPS, kept) : `${err.message.replace(/\.?$/, ".")} ${kept}`;
+    }
+    return err;
+}
+/** Bind the server, connect and read the declaration, run `body` with it, then close the connection. */
+async function withRun(args, signal, deps, body) {
+    try {
+        return await bound(args, signal, deps, body);
+    }
+    catch (err) {
+        throw noting(args, err);
+    }
+}
+async function bound(args, signal, deps, body) {
+    const cwd = args.cwd ?? process.cwd();
+    const config = deps.config ?? (await loadConfig(cwd));
+    const marker = resolveOwnershipMarker(args, config, "PostgresMigrationOp");
+    const target = await resolveBoundTarget({ ...(args.environment !== undefined ? { environment: args.environment } : {}), config: config ?? {}, ...(deps.env ? { env: deps.env } : {}) });
+    const json = readFileSync(resolve(cwd, args.buildPath), "utf8");
+    const objects = declaredObjects(json, target.defaultSchema);
+    const declared = declaredTable(objects, args.table);
+    const major = buildMajor(json) ?? config?.sql?.postgresMajor;
+    const lag = args.replicationLag;
+    const client = await (deps.connect ?? ((e) => connectPostgres(e, { applicationName: "chant migration" })))(target.endpoint);
+    const runId = currentOpRun()?.runId;
+    try {
+        return await body({
+            client,
+            target,
+            declared,
+            objects,
+            column: args.column,
+            ...(args.using !== undefined ? { using: args.using } : {}),
+            ...(marker ? { marker } : {}),
+            ...(major !== undefined ? { major } : {}),
+            batchSize: args.batchSize ?? 1000,
+            retainMs: parseDuration(args.retain ?? "7d"),
+            replicationLag: lag === false
+                ? false
+                : {
+                    maxLagMs: lag?.max !== undefined ? parseDuration(lag.max) : DEFAULT_REPLICATION_LAG.maxLagMs,
+                    waitMs: lag?.wait !== undefined ? parseDuration(lag.wait) : DEFAULT_REPLICATION_LAG.waitMs,
+                },
+            lockTimeoutMs: args.lockTimeoutMs ?? target.timeouts?.lockTimeoutMs ?? DEFAULT_POSTGRES_APPLY_TIMEOUTS.lockTimeoutMs,
+            statementTimeoutMs: args.statementTimeoutMs ?? target.timeouts?.statementTimeoutMs ?? DEFAULT_POSTGRES_APPLY_TIMEOUTS.statementTimeoutMs,
+            log: deps.log ?? ((line) => console.log(line)),
+            ...(signal ? { signal } : {}),
+            ...(runId ? { runId } : {}),
+        });
+    }
+    finally {
+        await client.end();
+    }
+}
+/** Plan: classify the column's change against the server and say how far the migration has got. */
+export async function postgresMigrationPlan(args, signal, deps = {}) {
+    return withRun(args, signal, deps, async (run) => {
+        const o = await observeMigration({
+            client: run.client,
+            target: run.target,
+            declared: run.declared,
+            ...(run.objects ? { objects: run.objects } : {}),
+            column: run.column,
+            ...(run.marker ? { marker: run.marker } : {}),
+            ...(run.using !== undefined ? { using: run.using } : {}),
+            ...(run.major !== undefined ? { major: run.major } : {}),
+        });
+        const n = o.names;
+        const changes = o.changes.map((c) => `${c.rule} ${c.field}${c.before !== undefined || c.after !== undefined ? `: ${c.before ?? "none"} -> ${c.after ?? "none"}` : ""}`);
+        const made = o.changes.filter((c) => c.rule === "SQLPG205" || c.rule === "SQLPG207" || c.rule === "SQLPG208").map((c) => `${c.rule} ${PG_CLASSIFIER_RULES[c.rule].title}`);
+        const summary = o.state === "migrate"
+            ? `${n.key} needs expand and contract (${made.join("; ")}): ${n.change === "rename" ? `${n.source} renamed to ${n.column}` : `${n.column} as ${o.column.type}, computed as ${o.expression}`}, batched by ${o.batchKey}${o.newColumn ? `; ${n.newColumn} already added` : ""}`
+            : o.state === "switched"
+                ? `${n.key} has been switched; the old column is kept as ${n.oldColumn}`
+                : `${n.key} holds its declaration; nothing to migrate`;
+        run.log(`-- ${summary}`);
+        for (const c of changes)
+            run.log(`--   ${c}`);
+        const classified = o.changes.map(statementChange);
+        const result = { state: o.state, migration: n.key, change: n.change, ...(o.state === "migrate" ? { planDigest: migrationPlanDigest(o) } : {}), changes, classified };
+        const part = postgresMigrationPart({ member: n.key, plan: result, ...(args.environment !== undefined ? { environment: args.environment } : {}) });
+        return { ...result, part, summary };
+    });
+}
+export async function postgresMigrationExpand(args, signal, deps = {}) {
+    return withRun(args, signal, deps, expand);
+}
+export async function postgresMigrationDualWrite(args, signal, deps = {}) {
+    return withRun(args, signal, deps, startDualWrite);
+}
+export async function postgresMigrationBackfill(args, signal, deps = {}) {
+    return withRun(args, signal, deps, (run) => backfill(run, deps.backfill));
+}
+/** Carry over: the indexes and constraints on the old column, made again on the new one. */
+export async function postgresMigrationCarry(args, signal, deps = {}) {
+    return withRun(args, signal, deps, carryOver);
+}
+export async function postgresMigrationVerify(args, signal, deps = {}) {
+    return withRun(args, signal, deps, verifyMigration);
+}
+export async function postgresMigrationSwitch(args, signal, deps = {}) {
+    return withRun(args, signal, deps, switchColumns);
+}
+export async function postgresMigrationRetain(args, signal, deps = {}) {
+    return withRun(args, signal, deps, retainPlan);
+}
+export async function postgresMigrationContract(args, signal, deps = {}) {
+    return withRun(args, signal, deps, contract);
+}
+/** onFailure: drop what the expand added. */
+export async function postgresMigrationCompensate(args, signal, deps = {}) {
+    return withRun(args, signal, deps, compensate);
+}

package/dist/op/activities/sql-exec.js

@@ -0,0 +1,57 @@
+/**
+ * `sqlExec` (#3657): run SQL on the environment's database server, the step
+ * an `effect()` batch of a sql project is made of.
+ *
+ *     effect(EffectReceipt("country-202601", { effect: "country/202601", flavor: "existence" }), [
+ *       activity("sqlExec", { sql: "ALTER TABLE shop.orders UPDATE country = 'NL' WHERE toYYYYMM(ts) = 202601" }, "atMostOnce"),
+ *     ])
+ *
+ * The server is the one `effect()`'s receipts are kept on
+ * (`../../receipts.ts`): `sql.profiles.<env>` for the environment
+ * `chant run --env` sets, else `CLICKHOUSE_URL` or `POSTGRES_URL`. `environment`
+ * in the arguments names another. On Postgres the SQL runs on a connection of
+ * its own with the role's default `search_path`, as one implicit transaction;
+ * on ClickHouse, `settings` are sent with the query.
+ */
+import { clickhouseQuery } from "../../clickhouse/http.js";
+import { bindClickHouse } from "../../clickhouse/live/bind.js";
+import { resolveBoundTarget } from "../../postgres/live/bind.js";
+import { connectPostgres } from "../../postgres/live/client.js";
+import { environmentOf, receiptDialect } from "../../receipts.js";
+async function loadConfig(cwd) {
+    try {
+        const { loadChantConfig } = await import("@intentius/chant/config");
+        return (await loadChantConfig(cwd)).config;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function sqlExec(args, signal, deps = {}) {
+    if (typeof args?.sql !== "string" || args.sql.trim() === "")
+        throw new Error('sqlExec: needs { sql: "<statement>" }');
+    signal?.throwIfAborted();
+    const env = deps.env ?? process.env;
+    const config = deps.config ?? (await loadConfig(args.cwd ?? process.cwd()));
+    const environment = environmentOf(args, config, env);
+    const log = deps.log ?? ((line) => console.log(line));
+    const where = environment !== undefined ? { environment } : {};
+    log(args.sql);
+    if (receiptDialect(config, environment, env) === "postgres") {
+        const target = await resolveBoundTarget({ ...where, config: config ?? {}, env });
+        const client = await connectPostgres(target.endpoint, { applicationName: "chant sqlExec" });
+        try {
+            // The catalog reader's empty search_path is not what a hand-written statement expects.
+            await client.query("RESET search_path");
+            const rows = await client.query(args.sql);
+            return { dialect: "postgres", source: target.source, rows: Array.isArray(rows) ? rows.length : 0 };
+        }
+        finally {
+            await client.end();
+        }
+    }
+    const target = await bindClickHouse({ ...where, config: config ?? {}, env });
+    const settings = args.settings ? Object.fromEntries(Object.entries(args.settings).map(([k, v]) => [k, String(v)])) : undefined;
+    const rows = await clickhouseQuery(target.endpoint, args.sql, { ...(settings ? { settings } : {}), ...(signal ? { signal } : {}) });
+    return { dialect: "clickhouse", source: target.source, rows: rows.length };
+}

package/dist/op/activity-contracts.js

@@ -0,0 +1,103 @@
+/**
+ * Activity contracts for the sql lexicon's own `op/activities` (chant #2101):
+ * the ClickHouse rebuild migration's steps (#3198) and the Postgres
+ * expand-and-contract migration's (#3281).
+ *
+ * `loadActivityContracts` imports this module at
+ * `@intentius/chant-lexicon-sql/op/activity-contracts` for every project that
+ * lists the sql lexicon, and core's OPS012 and OPS013 check every
+ * `ClickHouseRebuildOp` and `PostgresMigrationOp` step against it at
+ * `chant build`: the arguments, and the two references each Op makes into a
+ * step's return value, the verification's `planDigest` (the swap or switch
+ * gate) and the retention's `dropDigest` or `contractDigest` (the drop or
+ * contract gate). Arguments are `z.strictObject`, so a
+ * misspelled key fails the build instead of vanishing.
+ */
+import { z } from "zod";
+import { activityContract } from "@intentius/chant/op";
+const dualWrite = z.discriminatedUnion("mode", [
+    z.strictObject({ mode: z.literal("materialized-view"), cutoverColumn: z.string(), cutoverDelay: z.string().optional() }),
+    z.strictObject({ mode: z.literal("app") }),
+]);
+/** `ClickHouseRebuildArgs` (`../clickhouse/rebuild/op.ts`): the same for every step. */
+const rebuildArgs = z.strictObject({
+    table: z.string(),
+    buildPath: z.string(),
+    environment: z.string().optional(),
+    dualWrite,
+    retain: z.string().optional(),
+    mutationTimeout: z.string().optional(),
+    replicaTimeout: z.string().optional(),
+    cutoverTimeout: z.string().optional(),
+    stack: z.string().optional(),
+    ownershipEnv: z.string().optional(),
+    cwd: z.string().optional(),
+    keepOnFailure: z.boolean().optional(),
+});
+const state = z.enum(["rebuild", "swapped", "done"]);
+/** A plan step's structured changes and its change-set part (#3767), as `../change-set.ts` makes it. */
+const classified = z.array(z.object({ rule: z.string(), class: z.string(), field: z.string() }).passthrough());
+const part = z.object({ member: z.object({ member: z.string(), planner: z.literal("sql"), planDigest: z.string().nullable() }).passthrough(), entries: z.array(z.unknown()) });
+const tableEntity = { entities: ["table"] };
+export const clickhouseRebuildPlanContract = activityContract("clickhouseRebuildPlan", rebuildArgs, z.object({ state, table: z.string(), planDigest: z.string().optional(), changes: z.array(z.string()), classified, part, summary: z.string() }), tableEntity);
+export const clickhouseRebuildCreateContract = activityContract("clickhouseRebuildCreate", rebuildArgs, z.object({ state, table: z.string(), created: z.boolean() }), tableEntity);
+export const clickhouseRebuildDualWriteContract = activityContract("clickhouseRebuildDualWrite", rebuildArgs, z.object({ state, mode: z.enum(["materialized-view", "app"]), cutover: z.string().optional(), created: z.boolean() }), tableEntity);
+export const clickhouseRebuildBackfillContract = activityContract("clickhouseRebuildBackfill", rebuildArgs, z.object({ state, partitions: z.number(), copied: z.number(), skipped: z.number(), cleared: z.number() }), tableEntity);
+export const clickhouseRebuildVerifyContract = activityContract("clickhouseRebuildVerify", rebuildArgs, z.object({
+    state,
+    planDigest: z.string().optional(),
+    partitions: z.number(),
+    rows: z.number(),
+    summary: z.string(),
+    verification: z.array(z.object({ partition: z.string(), rows: z.number(), checksum: z.string() })),
+}), tableEntity);
+export const clickhouseRebuildSwapContract = activityContract("clickhouseRebuildSwap", rebuildArgs, z.object({ state, swapped: z.boolean(), dependents: z.array(z.string()), oldTable: z.string().optional(), retainUntil: z.string().optional() }), tableEntity);
+export const clickhouseRebuildRetainContract = activityContract("clickhouseRebuildRetain", rebuildArgs, z.object({ state, oldTable: z.string().optional(), retainUntil: z.string().optional(), due: z.boolean(), dropDigest: z.string().optional() }), tableEntity);
+export const clickhouseRebuildDropContract = activityContract("clickhouseRebuildDrop", rebuildArgs, z.object({ state, dropped: z.boolean(), oldTable: z.string().optional(), retainUntil: z.string().optional() }), tableEntity);
+export const clickhouseRebuildCompensateContract = activityContract("clickhouseRebuildCompensate", rebuildArgs, z.object({ dropped: z.array(z.string()) }), tableEntity);
+// ── PostgresMigrationOp (#3281) ────────────────────────────────────────
+/** `PostgresMigrationArgs` (`../postgres/migrate/op.ts`): the same for every step. */
+const migrationArgs = z.strictObject({
+    table: z.string(),
+    column: z.string(),
+    buildPath: z.string(),
+    environment: z.string().optional(),
+    using: z.string().optional(),
+    retain: z.string().optional(),
+    batchSize: z.number().int().positive().optional(),
+    replicationLag: z.union([z.literal(false), z.strictObject({ max: z.string().optional(), wait: z.string().optional() })]).optional(),
+    lockTimeoutMs: z.number().int().nonnegative().optional(),
+    statementTimeoutMs: z.number().int().nonnegative().optional(),
+    stack: z.string().optional(),
+    ownershipEnv: z.string().optional(),
+    cwd: z.string().optional(),
+    keepOnFailure: z.boolean().optional(),
+});
+const migrationState = z.enum(["migrate", "switched", "done"]);
+export const postgresMigrationPlanContract = activityContract("postgresMigrationPlan", migrationArgs, z.object({ state: migrationState, migration: z.string(), change: z.enum(["rename", "type"]), planDigest: z.string().optional(), changes: z.array(z.string()), classified, part, summary: z.string() }), tableEntity);
+export const postgresMigrationExpandContract = activityContract("postgresMigrationExpand", migrationArgs, z.object({ state: migrationState, column: z.string(), added: z.boolean() }), tableEntity);
+export const postgresMigrationDualWriteContract = activityContract("postgresMigrationDualWrite", migrationArgs, z.object({ state: migrationState, trigger: z.string(), created: z.boolean() }), tableEntity);
+export const postgresMigrationBackfillContract = activityContract("postgresMigrationBackfill", migrationArgs, z.object({ state: migrationState, batches: z.number(), filled: z.number(), skipped: z.number(), rows: z.number(), pausedMs: z.number() }), tableEntity);
+export const postgresMigrationCarryContract = activityContract("postgresMigrationCarry", migrationArgs, z.object({ state: migrationState, built: z.number(), ready: z.number(), views: z.number(), carried: z.array(z.string()) }), tableEntity);
+export const postgresMigrationVerifyContract = activityContract("postgresMigrationVerify", migrationArgs, z.object({
+    state: migrationState,
+    planDigest: z.string().optional(),
+    rows: z.number(),
+    mismatched: z.number(),
+    nulls: z.number(),
+    checksum: z.string(),
+    expected: z.string(),
+    summary: z.string(),
+}), tableEntity);
+export const postgresMigrationSwitchContract = activityContract("postgresMigrationSwitch", migrationArgs, z.object({ state: migrationState, switched: z.boolean(), oldColumn: z.string().optional(), retainUntil: z.string().optional() }), tableEntity);
+export const postgresMigrationRetainContract = activityContract("postgresMigrationRetain", migrationArgs, z.object({ state: migrationState, oldColumn: z.string().optional(), retainUntil: z.string().optional(), due: z.boolean(), contractDigest: z.string().optional() }), tableEntity);
+export const postgresMigrationContractContract = activityContract("postgresMigrationContract", migrationArgs, z.object({ state: migrationState, dropped: z.boolean(), oldColumn: z.string().optional(), retainUntil: z.string().optional() }), tableEntity);
+export const postgresMigrationCompensateContract = activityContract("postgresMigrationCompensate", migrationArgs, z.object({ dropped: z.array(z.string()) }), tableEntity);
+// ── effect() batches (#3657) ───────────────────────────────────────────
+/** `SqlExecArgs` (`./activities/sql-exec.ts`): one batch's SQL on the environment's server. */
+export const sqlExecContract = activityContract("sqlExec", z.strictObject({
+    sql: z.string().min(1),
+    environment: z.string().optional(),
+    settings: z.record(z.string(), z.union([z.string(), z.number()])).optional(),
+    cwd: z.string().optional(),
+}), z.object({ dialect: z.enum(["clickhouse", "postgres"]), source: z.string(), rows: z.number() }));

package/dist/package-cli.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env tsx
+/**
+ * Thin entry point for `npm run bundle` in lexicon-sql.
+ */
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { writeBundleSpec } from "@intentius/chant/codegen/package";
+import { generate, writeGeneratedFiles } from "./codegen/generate.js";
+import { packageLexicon } from "./codegen/package.js";
+const pkgDir = dirname(dirname(fileURLToPath(import.meta.url)));
+writeGeneratedFiles(await generate({ verbose: true }));
+const { spec, stats } = await packageLexicon({ verbose: true });
+writeBundleSpec(spec, join(pkgDir, "dist"));
+console.error(`Packaged ${stats.ruleCount} rules, ${stats.skillCount} skills`);