@agentic-kit/db-tools 0.2.0

package/provision-database/preset-match.js

@@ -0,0 +1,70 @@
+"use strict";
+// Client-side mirror of the backend's modules_hash normalization
+// (constructive-db: metaschema_private.modules_hash), used to decide whether a
+// resolved module set can be requested by preset slug — the warm-pool-eligible
+// path — or must be sent as an explicit modules array:
+//   1. A bare module name normalizes to [name, {}]; a missing/null options
+//      slot normalizes to {}.
+//   2. Options are compared verbatim after canonicalization (object keys
+//      sorted at every level) — no default-value normalization.
+//   3. Entries are sorted so the caller's ordering never affects the match.
+//   4. Duplicate normalized entries never match (the backend rejects them).
+// Only equality within this process matters, so string sort order does not
+// need to replicate PostgreSQL collation.
+//
+// The registry presets are the canonical definitions; the backend's
+// db_presets catalog is synced from them. A slug match assumes that sync —
+// preset drift would provision the backend's version of the set.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchPresetSlug = matchPresetSlug;
+exports.selectProvisionRequest = selectProvisionRequest;
+const presets_1 = require("./presets");
+function canonicalize(value) {
+    if (Array.isArray(value))
+        return value.map(canonicalize);
+    if (value && typeof value === 'object') {
+        const sorted = {};
+        for (const key of Object.keys(value).sort()) {
+            sorted[key] = canonicalize(value[key]);
+        }
+        return sorted;
+    }
+    return value;
+}
+function normalizedEntries(list) {
+    const entries = list.map((m) => {
+        const name = Array.isArray(m) ? m[0] : m;
+        const options = Array.isArray(m) ? (m[1] ?? {}) : {};
+        return JSON.stringify([name, canonicalize(options)]);
+    });
+    entries.sort();
+    for (let i = 1; i < entries.length; i++) {
+        if (entries[i] === entries[i - 1])
+            return null;
+    }
+    return entries;
+}
+/**
+ * The slug of the registry preset whose module set equals `resolved` under
+ * the backend's hash semantics, or undefined when no preset matches.
+ */
+function matchPresetSlug(resolved) {
+    const target = normalizedEntries(resolved)?.join('\n');
+    if (!target)
+        return undefined;
+    for (const preset of presets_1.allModulePresets) {
+        if (normalizedEntries(preset.modules)?.join('\n') === target) {
+            return preset.name;
+        }
+    }
+    return undefined;
+}
+/**
+ * Build the requestDatabase input branch: presetSlug when the resolved set
+ * equals a registry preset (warm-pool eligible), else the explicit modules
+ * array — never both.
+ */
+function selectProvisionRequest(resolved) {
+    const presetSlug = matchPresetSlug(resolved);
+    return presetSlug ? { presetSlug } : { modules: resolved };
+}

package/provision-database/presets.d.ts

@@ -0,0 +1,4 @@
+import { allModulePresets, getModulePreset, type ModulePreset } from 'node-type-registry';
+export type ProvisionModule = string | [string, Record<string, unknown>];
+export declare const DEFAULT_PROVISION_PRESET: string;
+export { allModulePresets, getModulePreset, type ModulePreset };

package/provision-database/presets.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModulePreset = exports.allModulePresets = exports.DEFAULT_PROVISION_PRESET = void 0;
+// Provision module presets — the canonical source of truth.
+//
+// The module list is NEVER hand-copied here. It is imported from the pinned
+// `node-type-registry` package (the same presets the backend and dashboard use),
+// so bumping that dependency is how the base module set moves. Hosts customize
+// on top with an ordered overlay (see `resolve.ts`) rather than editing a list.
+const node_type_registry_1 = require("node-type-registry");
+Object.defineProperty(exports, "allModulePresets", { enumerable: true, get: function () { return node_type_registry_1.allModulePresets; } });
+Object.defineProperty(exports, "getModulePreset", { enumerable: true, get: function () { return node_type_registry_1.getModulePreset; } });
+// Default base preset. `b2b:storage` = the full multi-tenant B2B shape plus file
+// storage, matching Constructive's app shape. It carries the app-scoped secret,
+// identity-provider, and storage modules the backend's provisioning requires —
+// the drift the old hand-copied list caused (a dropped, then bare/unscoped, set).
+exports.DEFAULT_PROVISION_PRESET = node_type_registry_1.PresetB2bStorage.name;

package/provision-database/request-database.d.ts

@@ -0,0 +1,61 @@
+import type { ProvisionModule } from './presets';
+/**
+ * Exactly one of presetSlug or modules — requestDatabase rejects both/neither
+ * (REQUEST_DATABASE_INVALID_INPUT). `selectProvisionRequest` (preset-match.ts)
+ * builds this from the resolved module set.
+ */
+export type ProvisionRequest = {
+    presetSlug: string;
+} | {
+    modules: ProvisionModule[];
+};
+export type ProvisionTicket = {
+    id?: string | null;
+    status?: string | null;
+    bootstrapStatus?: string | null;
+    databaseId?: string | null;
+    errorMessage?: string | null;
+    bootstrapError?: string | null;
+};
+/**
+ * Request + poll seam, injectable for tests (pattern: db-probe's
+ * ProbeExecutor). The default executor drives the SDK clients.
+ */
+export type ProvisionRequestExecutor = {
+    request(input: {
+        databaseName: string;
+        subdomain: string;
+        domain: string;
+        request: ProvisionRequest;
+    }): Promise<ProvisionTicket>;
+    poll(ticketId: string): Promise<ProvisionTicket | null>;
+};
+export declare const POLL_INTERVAL_MS = 2000;
+/** Stays under airpage's 5-minute per-tool timeout. */
+export declare const POLL_DEADLINE_MS = 240000;
+/**
+ * Consecutive unreadable polls tolerated before giving up. Provisioning keeps
+ * running server-side, so a dropped request or a momentary 502 must not abort
+ * a creation that is about to succeed.
+ */
+export declare const MAX_CONSECUTIVE_POLL_FAILURES = 3;
+/**
+ * Request a database and resolve only when it is fully usable: ticket
+ * `status` AND `bootstrapStatus` both 'completed'. The ticket the mutation
+ * returns is checked before the first sleep, so a warm claim with bootstrap
+ * already done never waits. `status: 'failed'` surfaces `errorMessage`;
+ * `bootstrapStatus: 'failed'` surfaces `bootstrapError`.
+ */
+export declare function requestDatabaseProvision(args: {
+    apiEndpoint: string;
+    modulesEndpoint: string;
+    bearer: string;
+    databaseName: string;
+    domain: string;
+    request: ProvisionRequest;
+    executor?: ProvisionRequestExecutor;
+    pollIntervalMs?: number;
+    pollDeadlineMs?: number;
+}): Promise<{
+    databaseId: string;
+}>;

package/provision-database/request-database.js

@@ -0,0 +1,134 @@
+"use strict";
+// Provision a database through the api endpoint's requestDatabase mutation —
+// the pool-aware entry point. The mutation returns a ticket (a
+// database_provision_module row) immediately: a warm-pool claim arrives
+// 'completed' with the deferred owner bootstrap still pending; a cold request
+// arrives 'pending' and is fulfilled asynchronously by the backend's jobs
+// worker. The ticket is polled on the MODULES endpoint (the api endpoint has
+// no ticket query) until BOTH status and bootstrapStatus are 'completed': pi
+// hands credentials to the agent as soon as this resolves, and until owner
+// bootstrap completes the new database has zero users, so its per-DB API
+// would reject the owner token under RLS. requestDatabase owns the database
+// to the JWT user — there is no owner input. The generated ORM's default
+// adapter is plain fetch, so the SDK's FetchAdapter is injected to keep
+// *.localhost DNS/Host routing working in Node.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_CONSECUTIVE_POLL_FAILURES = exports.POLL_DEADLINE_MS = exports.POLL_INTERVAL_MS = void 0;
+exports.requestDatabaseProvision = requestDatabaseProvision;
+const sdk_1 = require("@constructive-io/sdk");
+exports.POLL_INTERVAL_MS = 2_000;
+/** Stays under airpage's 5-minute per-tool timeout. */
+exports.POLL_DEADLINE_MS = 240_000;
+/**
+ * Consecutive unreadable polls tolerated before giving up. Provisioning keeps
+ * running server-side, so a dropped request or a momentary 502 must not abort
+ * a creation that is about to succeed.
+ */
+exports.MAX_CONSECUTIVE_POLL_FAILURES = 3;
+const TICKET_SELECT = {
+    id: true,
+    status: true,
+    bootstrapStatus: true,
+    databaseId: true,
+    errorMessage: true,
+    bootstrapError: true,
+};
+function createSdkExecutor(args) {
+    const headers = { Authorization: `Bearer ${args.bearer}` };
+    const apiClient = sdk_1.api.createClient({ adapter: new sdk_1.api.FetchAdapter(args.apiEndpoint, headers) });
+    const modulesClient = sdk_1.modules.createClient({
+        adapter: new sdk_1.api.FetchAdapter(args.modulesEndpoint, headers),
+    });
+    return {
+        async request(input) {
+            const requestInput = {
+                databaseName: input.databaseName,
+                subdomain: input.subdomain,
+                domain: input.domain,
+                ...('presetSlug' in input.request
+                    ? { presetSlug: input.request.presetSlug }
+                    : { modules: input.request.modules }),
+            };
+            const result = await apiClient.mutation
+                .requestDatabase({ input: requestInput }, { select: { result: { select: TICKET_SELECT } } })
+                .unwrap();
+            const ticket = result.requestDatabase?.result;
+            if (!ticket)
+                throw new Error('requestDatabase returned no provision ticket.');
+            return ticket;
+        },
+        async poll(ticketId) {
+            const result = await modulesClient.databaseProvisionModule
+                .findOne({ id: ticketId, select: TICKET_SELECT })
+                .unwrap();
+            return result.databaseProvisionModule ?? null;
+        },
+    };
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Request a database and resolve only when it is fully usable: ticket
+ * `status` AND `bootstrapStatus` both 'completed'. The ticket the mutation
+ * returns is checked before the first sleep, so a warm claim with bootstrap
+ * already done never waits. `status: 'failed'` surfaces `errorMessage`;
+ * `bootstrapStatus: 'failed'` surfaces `bootstrapError`.
+ */
+async function requestDatabaseProvision(args) {
+    const executor = args.executor ??
+        createSdkExecutor({
+            apiEndpoint: args.apiEndpoint,
+            modulesEndpoint: args.modulesEndpoint,
+            bearer: args.bearer,
+        });
+    const intervalMs = args.pollIntervalMs ?? exports.POLL_INTERVAL_MS;
+    const deadlineMs = args.pollDeadlineMs ?? exports.POLL_DEADLINE_MS;
+    let ticket = await executor.request({
+        databaseName: args.databaseName,
+        subdomain: args.databaseName,
+        domain: args.domain,
+        request: args.request,
+    });
+    const ticketId = ticket.id;
+    if (!ticketId)
+        throw new Error('requestDatabase returned a provision ticket without an id.');
+    const deadline = Date.now() + deadlineMs;
+    let failures = 0;
+    for (;;) {
+        if (ticket.status === 'failed') {
+            throw new Error(ticket.errorMessage ?? 'provisioning failed');
+        }
+        if (ticket.bootstrapStatus === 'failed') {
+            throw new Error(ticket.bootstrapError ?? 'owner bootstrap failed');
+        }
+        if (ticket.status === 'completed' && ticket.bootstrapStatus === 'completed') {
+            if (!ticket.databaseId)
+                throw new Error('provisioning completed but returned no databaseId.');
+            return { databaseId: ticket.databaseId };
+        }
+        if (Date.now() >= deadline) {
+            throw new Error(`provisioning timed out after ${Math.round(deadlineMs / 1000)}s (status: ${ticket.status ?? 'unknown'}, bootstrapStatus: ${ticket.bootstrapStatus ?? 'unknown'})`);
+        }
+        await sleep(intervalMs);
+        // A poll that throws (network blip, 502) or comes back empty is retried a
+        // few times rather than failing a provision that is still running.
+        let polled;
+        try {
+            polled = await executor.poll(ticketId);
+        }
+        catch (err) {
+            if (++failures > exports.MAX_CONSECUTIVE_POLL_FAILURES)
+                throw err;
+            continue;
+        }
+        if (!polled) {
+            if (++failures > exports.MAX_CONSECUTIVE_POLL_FAILURES) {
+                throw new Error(`provision ticket ${ticketId} could not be read back.`);
+            }
+            continue;
+        }
+        failures = 0;
+        ticket = polled;
+    }
+}

package/provision-database/resolve.d.ts

@@ -0,0 +1,27 @@
+import { type ProvisionModule } from './presets';
+export interface ProvisionOverlay {
+    /**
+     * Base preset name to resolve from (e.g. 'b2b:storage', 'full'). The last
+     * layer that sets `preset` wins; if none set it, `DEFAULT_PROVISION_PRESET`
+     * is used.
+     */
+    preset?: string;
+    /**
+     * Modules to add. An entry whose key matches an existing module OVERRIDES it
+     * (e.g. re-declaring `storage_module` with app-specific options); a new key
+     * is appended.
+     */
+    add?: ProvisionModule[];
+    /**
+     * Module names or `name:scope` keys to drop from the base. A bare name
+     * removes every scope of that module; `name:scope` removes just that one.
+     */
+    remove?: string[];
+}
+/** Stable identity for a module entry: `name` or `name:scope` when scoped. */
+export declare function moduleKey(m: ProvisionModule): string;
+/**
+ * Resolve the effective module list from a pinned preset plus ordered overlays.
+ * Pure: no I/O, no host access. Later overlays win (last-write-wins by key).
+ */
+export declare function resolveProvisionModules(layers?: ProvisionOverlay[]): ProvisionModule[];

package/provision-database/resolve.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.moduleKey = moduleKey;
+exports.resolveProvisionModules = resolveProvisionModules;
+// Ordered-overlay resolution for provision modules.
+//
+// Mirrors the skills overlay model (`@agentic-kit/harness` skills manifest): a
+// pinned base (a named preset from `node-type-registry`) is layered under zero
+// or more overlays, later layers winning by module key. An empty overlay list
+// resolves to the base preset unchanged.
+const presets_1 = require("./presets");
+function moduleName(m) {
+    return Array.isArray(m) ? m[0] : m;
+}
+function moduleScope(m) {
+    if (!Array.isArray(m))
+        return undefined;
+    const scope = m[1]?.scope;
+    return typeof scope === 'string' ? scope : undefined;
+}
+/** Stable identity for a module entry: `name` or `name:scope` when scoped. */
+function moduleKey(m) {
+    const scope = moduleScope(m);
+    return scope ? `${moduleName(m)}:${scope}` : moduleName(m);
+}
+/**
+ * Resolve the effective module list from a pinned preset plus ordered overlays.
+ * Pure: no I/O, no host access. Later overlays win (last-write-wins by key).
+ */
+function resolveProvisionModules(layers = []) {
+    const presetName = [...layers].reverse().find((l) => l.preset)?.preset ?? presets_1.DEFAULT_PROVISION_PRESET;
+    const preset = (0, presets_1.getModulePreset)(presetName);
+    if (!preset) {
+        const known = presets_1.allModulePresets.map((p) => p.name).join(', ');
+        throw new Error(`Unknown provision preset "${presetName}". Known presets: ${known}.`);
+    }
+    // Ordered map keyed by module identity preserves position while allowing
+    // overrides (same key) and appends (new key).
+    const resolved = new Map();
+    for (const m of preset.modules)
+        resolved.set(moduleKey(m), m);
+    for (const layer of layers) {
+        for (const target of layer.remove ?? []) {
+            for (const key of [...resolved.keys()]) {
+                if (key === target || key.split(':')[0] === target)
+                    resolved.delete(key);
+            }
+        }
+        for (const m of layer.add ?? [])
+            resolved.set(moduleKey(m), m);
+    }
+    return [...resolved.values()];
+}

package/records/meta.d.ts

@@ -0,0 +1,41 @@
+import type { Table, TableInflection } from '@constructive-io/graphql-query/types/schema';
+export declare const META_QUERY = "\n  query DbToolsMeta {\n    _meta {\n      tables {\n        name\n        query { all one create update delete }\n        inflection {\n          allRows\n          conditionType\n          connection\n          createInputType\n          createPayloadType\n          deletePayloadType\n          edge\n          filterType\n          orderByType\n          patchType\n          tableType\n          updatePayloadType\n        }\n        fields {\n          name\n          isNotNull\n          hasDefault\n          type {\n            gqlType\n            isArray\n            pgType\n            subtype\n            isNotNull\n            hasDefault\n          }\n        }\n      }\n    }\n  }\n";
+type RawType = {
+    gqlType: string;
+    isArray: boolean;
+    modifier?: string | number | null;
+    pgAlias?: string | null;
+    pgType?: string | null;
+    subtype?: string | null;
+    typmod?: number | null;
+    isNotNull?: boolean | null;
+    hasDefault?: boolean | null;
+};
+type RawField = {
+    name: string;
+    isNotNull?: boolean | null;
+    hasDefault?: boolean | null;
+    type: RawType;
+};
+type RawInflection = Partial<Record<keyof TableInflection, string | null>>;
+type RawQuery = {
+    all: string | null;
+    one?: string | null;
+    create?: string | null;
+    update?: string | null;
+    delete?: string | null;
+};
+export type RawMetaTable = {
+    name: string;
+    query?: RawQuery | null;
+    inflection?: RawInflection | null;
+    fields?: (RawField | null)[] | null;
+};
+export type MetaResponse = {
+    _meta?: {
+        tables?: (RawMetaTable | null)[] | null;
+    } | null;
+};
+export declare function cleanTable(meta: RawMetaTable): Table;
+export declare function findMetaTable(tables: RawMetaTable[], requested: string): RawMetaTable | undefined;
+export {};

package/records/meta.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.META_QUERY = void 0;
+exports.cleanTable = cleanTable;
+exports.findMetaTable = findMetaTable;
+// Vendored from constructive-client's `@constructive-io/data` (not published to
+// the registry). We query the per-DB data endpoint's `_meta` introspection and
+// reshape each table into the `Table` shape `buildPostGraphileCreate` expects.
+// Relations are intentionally left empty: the create-mutation builder only reads
+// them to skip relational fields in the return selection, and every `_meta` field
+// is a real scalar column, so selecting them all is valid.
+//
+// Only fields the live backend's `_meta` actually exposes are selected here —
+// over-selecting (e.g. MetaType.modifier or MetaInflection.createField) fails
+// GraphQL validation. The reshapers below tolerate the omitted fields.
+exports.META_QUERY = `
+  query DbToolsMeta {
+    _meta {
+      tables {
+        name
+        query { all one create update delete }
+        inflection {
+          allRows
+          conditionType
+          connection
+          createInputType
+          createPayloadType
+          deletePayloadType
+          edge
+          filterType
+          orderByType
+          patchType
+          tableType
+          updatePayloadType
+        }
+        fields {
+          name
+          isNotNull
+          hasDefault
+          type {
+            gqlType
+            isArray
+            pgType
+            subtype
+            isNotNull
+            hasDefault
+          }
+        }
+      }
+    }
+  }
+`;
+function convertInflection(inflection) {
+    if (!inflection)
+        return undefined;
+    const s = (key) => inflection[key] ?? '';
+    const n = (key) => inflection[key] ?? null;
+    return {
+        allRows: s('allRows'),
+        allRowsSimple: s('allRowsSimple'),
+        conditionType: s('conditionType'),
+        connection: s('connection'),
+        createField: s('createField'),
+        createInputType: s('createInputType'),
+        createPayloadType: s('createPayloadType'),
+        deleteByPrimaryKey: n('deleteByPrimaryKey'),
+        deletePayloadType: s('deletePayloadType'),
+        edge: s('edge'),
+        edgeField: s('edgeField'),
+        enumType: s('enumType'),
+        filterType: n('filterType'),
+        inputType: s('inputType'),
+        orderByType: s('orderByType'),
+        patchField: s('patchField'),
+        patchType: n('patchType'),
+        tableFieldName: s('tableFieldName'),
+        tableType: s('tableType'),
+        typeName: s('typeName'),
+        updateByPrimaryKey: n('updateByPrimaryKey'),
+        updatePayloadType: n('updatePayloadType'),
+    };
+}
+function convertQuery(query) {
+    if (!query)
+        return undefined;
+    return {
+        all: query.all ?? '',
+        one: query.one ?? null,
+        create: query.create ?? '',
+        update: query.update ?? null,
+        delete: query.delete ?? null,
+    };
+}
+function cleanTable(meta) {
+    return {
+        name: meta.name,
+        inflection: convertInflection(meta.inflection),
+        query: convertQuery(meta.query),
+        fields: (meta.fields ?? [])
+            .filter((f) => Boolean(f))
+            .map((field) => ({
+            name: field.name,
+            type: {
+                gqlType: field.type.gqlType,
+                isArray: field.type.isArray,
+                modifier: field.type.modifier,
+                pgAlias: field.type.pgAlias,
+                pgType: field.type.pgType,
+                subtype: field.type.subtype,
+                typmod: field.type.typmod,
+            },
+            isNotNull: field.isNotNull ?? field.type.isNotNull ?? null,
+            hasDefault: field.hasDefault ?? field.type.hasDefault ?? null,
+        })),
+        relations: { belongsTo: [], hasOne: [], hasMany: [], manyToMany: [] },
+    };
+}
+function normalizeTableLookupKey(value) {
+    return (value ?? '')
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]/g, '');
+}
+function getTableLookupVariants(value) {
+    const normalized = normalizeTableLookupKey(value);
+    if (!normalized)
+        return [];
+    const variants = new Set([normalized]);
+    if (normalized.endsWith('y')) {
+        variants.add(`${normalized}s`);
+        variants.add(`${normalized.slice(0, -1)}ies`);
+    }
+    if (normalized.endsWith('ies')) {
+        variants.add(`${normalized.slice(0, -3)}y`);
+    }
+    if (/(s|x|z|ch|sh)$/.test(normalized))
+        variants.add(`${normalized}es`);
+    if (normalized.endsWith('es'))
+        variants.add(normalized.slice(0, -2));
+    if (!normalized.endsWith('s'))
+        variants.add(`${normalized}s`);
+    if (normalized.endsWith('s'))
+        variants.add(normalized.slice(0, -1));
+    return [...variants].filter(Boolean);
+}
+// Resolve a user-supplied table name (snake_case singular or plural) against the
+// PascalCase-singular `_meta` table names, tolerating pluralization differences.
+function findMetaTable(tables, requested) {
+    const index = new Map();
+    for (const table of tables) {
+        const keys = [
+            table.name,
+            table.query?.all,
+            table.query?.one,
+            table.inflection?.tableType,
+            table.inflection?.tableFieldName,
+            table.inflection?.allRows,
+        ];
+        for (const key of keys) {
+            for (const variant of getTableLookupVariants(key)) {
+                if (!index.has(variant))
+                    index.set(variant, table);
+            }
+        }
+    }
+    for (const variant of getTableLookupVariants(requested)) {
+        const match = index.get(variant);
+        if (match)
+            return match;
+    }
+    return undefined;
+}

package/run-codegen/barrels.d.ts

@@ -0,0 +1,3 @@
+/** Rewrite directory barrel specifiers under `root` in place. Returns the count
+ * of files changed. No-op (returns 0) when `root` does not exist. */
+export declare function normalizeSdkBarrels(root: string): number;

package/run-codegen/barrels.js

@@ -0,0 +1,54 @@
+"use strict";
+// Turbopack barrel normalization (TURBOPACK-BARREL-001).
+//
+// Codegen emits directory barrel re-exports like `export * from './hooks'` where
+// `./hooks` is a directory with an index.ts. Next.js 16's Turbopack cannot
+// resolve directory specifiers — it needs an explicit `./hooks/index`. This pass
+// rewrites `./X` -> `./X/index` only when X resolves to a sibling DIRECTORY,
+// leaving file specifiers (and ones already ending in /index) untouched.
+//
+// Pure-ish: operates on a real directory tree (so it's exercised with a temp
+// fixture in tests) and is idempotent — safe to re-run.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeSdkBarrels = normalizeSdkBarrels;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const SPEC_RE = /((?:export|import)[^\n]*?from\s*["'])(\.\.?\/[^"']+?)(["'])/g;
+const FILE_EXT_RE = /\.(tsx?|jsx?|json|css)$/;
+/** Rewrite directory barrel specifiers under `root` in place. Returns the count
+ * of files changed. No-op (returns 0) when `root` does not exist. */
+function normalizeSdkBarrels(root) {
+    if (!node_fs_1.default.existsSync(root))
+        return 0;
+    let changed = 0;
+    const walk = (dir) => {
+        for (const entry of node_fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+            const p = node_path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(p);
+                continue;
+            }
+            if (!/\.tsx?$/.test(entry.name))
+                continue;
+            const orig = node_fs_1.default.readFileSync(p, 'utf8');
+            const next = orig.replace(SPEC_RE, (match, pre, spec, post) => {
+                if (FILE_EXT_RE.test(spec))
+                    return match; // already a file
+                const abs = node_path_1.default.resolve(node_path_1.default.dirname(p), spec);
+                if (node_fs_1.default.existsSync(abs) && node_fs_1.default.statSync(abs).isDirectory()) {
+                    return pre + spec.replace(/\/$/, '') + '/index' + post;
+                }
+                return match;
+            });
+            if (next !== orig) {
+                node_fs_1.default.writeFileSync(p, next);
+                changed++;
+            }
+        }
+    };
+    walk(root);
+    return changed;
+}

package/run-codegen/endpoints.d.ts

@@ -0,0 +1,8 @@
+export type PlaneEndpoints = {
+    admin: string;
+    auth: string;
+    app: string;
+};
+export declare function derivePlaneEndpoints(apiEndpoint: string, databaseName: string): PlaneEndpoints | undefined;
+export declare function codegenEndpointEnv(planes: PlaneEndpoints): Record<string, string>;
+export declare function envLocalContent(databaseName: string, planes: PlaneEndpoints | undefined): string;