@pikku/kysely 0.13.2 → 0.13.4

package/dist/src/kysely-workflow-mirror.js

@@ -1,4 +1,5 @@
-import { sql } from 'kysely';
+import { ensurePikkuSchema } from './schema/index.js';
+import { workflowSchema } from './schema/workflow.schema.js';
 /**
  * Kysely-backed `WorkflowRunMirror`.
  *
@@ -18,96 +19,18 @@ export class KyselyWorkflowMirror {
         this.db = db;
     }
     /**
-     * Create the underlying tables if they don't exist. Safe to call from
-     * either the mirror or `KyselyWorkflowService.init()` — schema is the
-     * same and uses `ifNotExists`.
+     * Create the underlying tables if none of them exist yet.
+     *
+     * Safe to call from either the mirror or `KyselyWorkflowService.init()` —
+     * both apply the same `workflowSchema`, and `ensurePikkuSchema` is a no-op
+     * once the tables are there. A database holding only *part* of the schema
+     * throws rather than filling in the rest: something else owns those tables,
+     * and boot is not where that gets reconciled.
      */
     async init() {
         if (this.initialized)
             return;
-        await this.db.schema
-            .createTable('workflow_runs')
-            .ifNotExists()
-            .addColumn('workflow_run_id', 'text', (col) => col.primaryKey())
-            .addColumn('workflow', 'text', (col) => col.notNull())
-            .addColumn('status', 'text', (col) => col.notNull())
-            .addColumn('input', 'text', (col) => col.notNull())
-            .addColumn('output', 'text')
-            .addColumn('error', 'text')
-            .addColumn('state', 'text', (col) => col.defaultTo('{}'))
-            .addColumn('inline', 'boolean', (col) => col.defaultTo(false))
-            .addColumn('graph_hash', 'text')
-            .addColumn('deterministic', 'boolean', (col) => col.defaultTo(false))
-            .addColumn('planned_steps', 'text')
-            .addColumn('wire', 'text')
-            .addColumn('created_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .addColumn('updated_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .execute();
-        await this.db.schema
-            .createTable('workflow_step')
-            .ifNotExists()
-            .addColumn('workflow_step_id', 'text', (col) => col.primaryKey())
-            .addColumn('workflow_run_id', 'text', (col) => col
-            .notNull()
-            .references('workflow_runs.workflow_run_id')
-            .onDelete('cascade'))
-            .addColumn('step_name', 'text', (col) => col.notNull())
-            .addColumn('rpc_name', 'text')
-            .addColumn('data', 'text')
-            .addColumn('status', 'text', (col) => col.notNull().defaultTo('pending'))
-            .addColumn('result', 'text')
-            .addColumn('error', 'text')
-            .addColumn('child_run_id', 'text')
-            .addColumn('branch_taken', 'text')
-            .addColumn('retries', 'integer')
-            .addColumn('retry_delay', 'text')
-            .addColumn('from_step_name', 'text')
-            .addColumn('created_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .addColumn('updated_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .addUniqueConstraint('workflow_step_run_name_unique', [
-            'workflow_run_id',
-            'step_name',
-        ])
-            .execute();
-        // Additive: backfill the column on mirror tables created before from_step_name.
-        await this.db.schema
-            .alterTable('workflow_step')
-            .addColumn('from_step_name', 'text')
-            .execute()
-            .catch(() => {
-            // Column already exists (fresh tables include it above) — nothing to do.
-        });
-        await this.db.schema
-            .createTable('workflow_step_history')
-            .ifNotExists()
-            .addColumn('history_id', 'text', (col) => col.primaryKey())
-            .addColumn('workflow_step_id', 'text', (col) => col
-            .notNull()
-            .references('workflow_step.workflow_step_id')
-            .onDelete('cascade'))
-            .addColumn('status', 'text', (col) => col.notNull())
-            .addColumn('result', 'text')
-            .addColumn('error', 'text')
-            .addColumn('created_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .addColumn('running_at', 'timestamp')
-            .addColumn('scheduled_at', 'timestamp')
-            .addColumn('succeeded_at', 'timestamp')
-            .addColumn('failed_at', 'timestamp')
-            .execute();
-        await this.db.schema
-            .createTable('workflow_versions')
-            .ifNotExists()
-            .addColumn('workflow_name', 'text', (col) => col.notNull())
-            .addColumn('graph_hash', 'text', (col) => col.notNull())
-            .addColumn('graph', 'text', (col) => col.notNull())
-            .addColumn('source', 'text', (col) => col.notNull())
-            .addColumn('status', 'text', (col) => col.notNull().defaultTo('active'))
-            .addColumn('created_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .addPrimaryKeyConstraint('workflow_versions_pk', [
-            'workflow_name',
-            'graph_hash',
-        ])
-            .execute();
+        await ensurePikkuSchema(this.db, workflowSchema);
         this.initialized = true;
     }
     async createRun(runId, workflowName, input, inline, graphHash, wire, options) {

package/dist/src/kysely-workflow-service.d.ts

@@ -1,12 +1,12 @@
 import type { SerializedError } from '@pikku/core';
-import { PikkuWorkflowService, type WorkflowPlannedStep, type WorkflowRun, type WorkflowRunWire, type StepState, type StepStatus, type WorkflowStatus, type WorkflowVersionStatus } from '@pikku/core/workflow';
+import { PikkuWorkflowService, type WorkflowPlannedStep, type WorkflowQueueOptions, type WorkflowRun, type WorkflowRunWire, type StepState, type StepStatus, type WorkflowStatus, type WorkflowVersionStatus } from '@pikku/core/workflow';
 import type { Kysely } from 'kysely';
 import type { KyselyPikkuDB } from './kysely-tables.js';
 export declare class KyselyWorkflowService extends PikkuWorkflowService {
     protected db: Kysely<KyselyPikkuDB>;
     private initialized;
     private runService;
-    constructor(db: Kysely<KyselyPikkuDB>);
+    constructor(db: Kysely<KyselyPikkuDB>, options?: WorkflowQueueOptions);
     init(): Promise<void>;
     protected createRunImpl(workflowName: string, input: any, inline: boolean, graphHash: string, wire: WorkflowRunWire, options?: {
         deterministic?: boolean;

package/dist/src/kysely-workflow-service.js

@@ -1,109 +1,21 @@
 import { PikkuWorkflowService, } from '@pikku/core/workflow';
-import { sql } from 'kysely';
 import { KyselyWorkflowRunService } from './kysely-workflow-run-service.js';
 import { parseJson } from './kysely-json.js';
+import { ensurePikkuSchema } from './schema/index.js';
+import { workflowSchema } from './schema/workflow.schema.js';
 export class KyselyWorkflowService extends PikkuWorkflowService {
     db;
     initialized = false;
     runService;
-    constructor(db) {
-        super();
+    constructor(db, options = {}) {
+        super(options);
         this.db = db;
         this.runService = new KyselyWorkflowRunService(db);
     }
     async init() {
-        if (this.initialized) {
+        if (this.initialized)
             return;
-        }
-        await this.db.schema
-            .createTable('workflow_runs')
-            .ifNotExists()
-            .addColumn('workflow_run_id', 'text', (col) => col
-            .primaryKey()
-            .defaultTo(sql `${sql.raw("'" + crypto.randomUUID() + "'")}`))
-            .addColumn('workflow', 'text', (col) => col.notNull())
-            .addColumn('status', 'text', (col) => col.notNull())
-            .addColumn('input', 'text', (col) => col.notNull())
-            .addColumn('output', 'text')
-            .addColumn('error', 'text')
-            .addColumn('state', 'text', (col) => col.defaultTo('{}'))
-            .addColumn('inline', 'boolean', (col) => col.defaultTo(false))
-            .addColumn('graph_hash', 'text')
-            .addColumn('deterministic', 'boolean', (col) => col.defaultTo(false))
-            .addColumn('planned_steps', 'text')
-            .addColumn('wire', 'text')
-            .addColumn('created_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .addColumn('updated_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .execute();
-        await this.db.schema
-            .createTable('workflow_step')
-            .ifNotExists()
-            .addColumn('workflow_step_id', 'text', (col) => col
-            .primaryKey()
-            .defaultTo(sql `${sql.raw("'" + crypto.randomUUID() + "'")}`))
-            .addColumn('workflow_run_id', 'text', (col) => col
-            .notNull()
-            .references('workflow_runs.workflow_run_id')
-            .onDelete('cascade'))
-            .addColumn('step_name', 'text', (col) => col.notNull())
-            .addColumn('rpc_name', 'text')
-            .addColumn('data', 'text')
-            .addColumn('status', 'text', (col) => col.notNull().defaultTo('pending'))
-            .addColumn('result', 'text')
-            .addColumn('error', 'text')
-            .addColumn('child_run_id', 'text')
-            .addColumn('branch_taken', 'text')
-            .addColumn('retries', 'integer')
-            .addColumn('retry_delay', 'text')
-            .addColumn('from_step_name', 'text')
-            .addColumn('created_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .addColumn('updated_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .addUniqueConstraint('workflow_step_run_name_unique', [
-            'workflow_run_id',
-            'step_name',
-        ])
-            .execute();
-        // Additive: backfill the column on tables created before from_step_name.
-        await this.db.schema
-            .alterTable('workflow_step')
-            .addColumn('from_step_name', 'text')
-            .execute()
-            .catch(() => {
-            // Column already exists (fresh tables include it above) — nothing to do.
-        });
-        await this.db.schema
-            .createTable('workflow_step_history')
-            .ifNotExists()
-            .addColumn('history_id', 'text', (col) => col
-            .primaryKey()
-            .defaultTo(sql `${sql.raw("'" + crypto.randomUUID() + "'")}`))
-            .addColumn('workflow_step_id', 'text', (col) => col
-            .notNull()
-            .references('workflow_step.workflow_step_id')
-            .onDelete('cascade'))
-            .addColumn('status', 'text', (col) => col.notNull())
-            .addColumn('result', 'text')
-            .addColumn('error', 'text')
-            .addColumn('created_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .addColumn('running_at', 'timestamp')
-            .addColumn('scheduled_at', 'timestamp')
-            .addColumn('succeeded_at', 'timestamp')
-            .addColumn('failed_at', 'timestamp')
-            .execute();
-        await this.db.schema
-            .createTable('workflow_versions')
-            .ifNotExists()
-            .addColumn('workflow_name', 'text', (col) => col.notNull())
-            .addColumn('graph_hash', 'text', (col) => col.notNull())
-            .addColumn('graph', 'text', (col) => col.notNull())
-            .addColumn('source', 'text', (col) => col.notNull())
-            .addColumn('status', 'text', (col) => col.notNull().defaultTo('active'))
-            .addColumn('created_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
-            .addPrimaryKeyConstraint('workflow_versions_pk', [
-            'workflow_name',
-            'graph_hash',
-        ])
-            .execute();
+        await ensurePikkuSchema(this.db, workflowSchema);
         this.initialized = true;
     }
     async createRunImpl(workflowName, input, inline, graphHash, wire, options) {
@@ -308,7 +220,11 @@ export class KyselyWorkflowService extends PikkuWorkflowService {
         if (latestHistory) {
             await this.db
                 .updateTable('workflowStepHistory')
-                .set({ status: 'succeeded', result: resultJson, succeededAt: new Date() })
+                .set({
+                status: 'succeeded',
+                result: resultJson,
+                succeededAt: new Date(),
+            })
                 .where('historyId', '=', latestHistory.historyId)
                 .execute();
         }

package/dist/src/schema/ai.schema.d.ts

@@ -0,0 +1,12 @@
+import type { PikkuSchema } from './pikku-schema.types.js';
+/**
+ * Threads, messages, tool calls, working memory and agent runs.
+ *
+ * `aiRun` carries `pendingApprovals` even though the two services that used to
+ * create this table disagreed about it: `KyselyAIStorageService` omitted the
+ * column while `KyselyAIRunStateService` declared it and read it back through
+ * casts. Whichever service happened to run first decided the shape, and on a
+ * database where the storage service won, resolving an approval failed. One
+ * declaration ends that — the column is here because live code reads it.
+ */
+export declare const aiSchema: PikkuSchema;

package/dist/src/schema/ai.schema.js

@@ -0,0 +1,89 @@
+import { sql } from 'kysely';
+/**
+ * Threads, messages, tool calls, working memory and agent runs.
+ *
+ * `aiRun` carries `pendingApprovals` even though the two services that used to
+ * create this table disagreed about it: `KyselyAIStorageService` omitted the
+ * column while `KyselyAIRunStateService` declared it and read it back through
+ * casts. Whichever service happened to run first decided the shape, and on a
+ * database where the storage service won, resolving an approval failed. One
+ * declaration ends that — the column is here because live code reads it.
+ */
+export const aiSchema = {
+    name: 'ai',
+    statements: [
+        (db) => db.schema
+            .createTable('aiThreads')
+            .addColumn('id', 'varchar(36)', (col) => col.primaryKey())
+            .addColumn('resourceId', 'varchar(255)', (col) => col.notNull())
+            .addColumn('title', 'text')
+            .addColumn('metadata', 'text')
+            .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
+            .addColumn('updatedAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull()),
+        (db) => db.schema
+            .createIndex('idx_ai_threads_resource')
+            .on('aiThreads')
+            .column('resourceId'),
+        (db) => db.schema
+            .createTable('aiMessage')
+            .addColumn('id', 'varchar(36)', (col) => col.primaryKey())
+            .addColumn('threadId', 'varchar(36)', (col) => col.notNull().references('aiThreads.id').onDelete('cascade'))
+            .addColumn('role', 'varchar(50)', (col) => col.notNull())
+            .addColumn('content', 'text')
+            .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull()),
+        (db) => db.schema
+            .createIndex('idx_ai_message_thread')
+            .on('aiMessage')
+            .columns(['threadId', 'createdAt']),
+        (db) => db.schema
+            .createTable('aiToolCall')
+            .addColumn('id', 'varchar(36)', (col) => col.primaryKey())
+            .addColumn('threadId', 'varchar(36)', (col) => col.notNull().references('aiThreads.id').onDelete('cascade'))
+            .addColumn('messageId', 'varchar(36)', (col) => col.notNull().references('aiMessage.id').onDelete('cascade'))
+            .addColumn('runId', 'varchar(36)')
+            .addColumn('toolName', 'varchar(255)', (col) => col.notNull())
+            .addColumn('args', 'text', (col) => col.notNull())
+            .addColumn('result', 'text')
+            .addColumn('approvalStatus', 'varchar(50)')
+            .addColumn('approvalType', 'varchar(50)')
+            .addColumn('agentRunId', 'varchar(36)')
+            .addColumn('displayToolName', 'varchar(255)')
+            .addColumn('displayArgs', 'text')
+            .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull()),
+        (db) => db.schema
+            .createIndex('idx_ai_tool_call_thread')
+            .on('aiToolCall')
+            .column('threadId'),
+        (db) => db.schema
+            .createIndex('idx_ai_tool_call_message')
+            .on('aiToolCall')
+            .column('messageId'),
+        (db) => db.schema
+            .createTable('aiWorkingMemory')
+            .addColumn('id', 'varchar(255)', (col) => col.notNull())
+            .addColumn('scope', 'varchar(50)', (col) => col.notNull())
+            .addColumn('data', 'text', (col) => col.notNull())
+            .addColumn('updatedAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
+            .addPrimaryKeyConstraint('ai_working_memory_pk', ['id', 'scope']),
+        (db) => db.schema
+            .createTable('aiRun')
+            .addColumn('runId', 'varchar(36)', (col) => col.primaryKey())
+            .addColumn('agentName', 'varchar(255)', (col) => col.notNull())
+            .addColumn('threadId', 'varchar(36)', (col) => col.notNull().references('aiThreads.id').onDelete('cascade'))
+            .addColumn('resourceId', 'varchar(255)', (col) => col.notNull())
+            .addColumn('status', 'varchar(50)', (col) => col.notNull().defaultTo('running'))
+            .addColumn('errorMessage', 'text')
+            .addColumn('suspendReason', 'text')
+            .addColumn('missingRpcs', 'text')
+            .addColumn('pendingApprovals', 'text')
+            .addColumn('usageInputTokens', 'integer', (col) => col.notNull().defaultTo(0))
+            .addColumn('usageOutputTokens', 'integer', (col) => col.notNull().defaultTo(0))
+            .addColumn('usageModel', 'varchar(255)', (col) => col.notNull().defaultTo(''))
+            .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
+            .addColumn('updatedAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull()),
+        (db) => db.schema
+            .createIndex('idx_ai_run_thread')
+            .on('aiRun')
+            .columns(['threadId', 'createdAt']),
+    ],
+};

package/dist/src/schema/channel.schema.d.ts

@@ -0,0 +1,3 @@
+import type { PikkuSchema } from './pikku-schema.types.js';
+/** Channels and their topic subscriptions, also read by the event-hub store. */
+export declare const channelSchema: PikkuSchema;

package/dist/src/schema/channel.schema.js

@@ -0,0 +1,24 @@
+import { sql } from 'kysely';
+/** Channels and their topic subscriptions, also read by the event-hub store. */
+export const channelSchema = {
+    name: 'channel',
+    statements: [
+        (db) => db.schema
+            .createTable('channels')
+            .addColumn('channelId', 'text', (col) => col.primaryKey())
+            .addColumn('channelName', 'text', (col) => col.notNull())
+            .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
+            .addColumn('openingData', 'text', (col) => col.notNull().defaultTo('{}'))
+            .addColumn('pikkuUserId', 'text')
+            .addColumn('state', 'text')
+            .addColumn('lastWire', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull()),
+        (db) => db.schema
+            .createTable('channelSubscriptions')
+            .addColumn('channelId', 'text', (col) => col.notNull().references('channels.channelId').onDelete('cascade'))
+            .addColumn('topic', 'text', (col) => col.notNull())
+            .addPrimaryKeyConstraint('channel_subscriptions_pk', [
+            'channelId',
+            'topic',
+        ]),
+    ],
+};

package/dist/src/schema/credential.schema.d.ts

@@ -0,0 +1,11 @@
+import { type PikkuSchema } from './pikku-schema.types.js';
+/**
+ * Encrypted per-user credentials and their audit trail.
+ *
+ * The uniqueness rule is an expression index — `user_id` is nullable and two
+ * rows with a null user must still collide on name — which the schema builder
+ * cannot express, so it stays raw. Raw SQL is not rewritten by `withSchema`,
+ * which is why the table is named explicitly rather than left to the search
+ * path.
+ */
+export declare const credentialSchema: PikkuSchema;

package/dist/src/schema/credential.schema.js

@@ -0,0 +1,33 @@
+import { sql } from 'kysely';
+import { rawStatement } from './pikku-schema.types.js';
+/**
+ * Encrypted per-user credentials and their audit trail.
+ *
+ * The uniqueness rule is an expression index — `user_id` is nullable and two
+ * rows with a null user must still collide on name — which the schema builder
+ * cannot express, so it stays raw. Raw SQL is not rewritten by `withSchema`,
+ * which is why the table is named explicitly rather than left to the search
+ * path.
+ */
+export const credentialSchema = {
+    name: 'credential',
+    statements: [
+        (db) => db.schema
+            .createTable('credentials')
+            .addColumn('name', 'varchar(255)', (col) => col.notNull())
+            .addColumn('userId', 'varchar(255)')
+            .addColumn('ciphertext', 'text', (col) => col.notNull())
+            .addColumn('wrappedDek', 'text', (col) => col.notNull())
+            .addColumn('keyVersion', 'integer', (col) => col.notNull())
+            .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
+            .addColumn('updatedAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull()),
+        rawStatement(sql `CREATE UNIQUE INDEX credentials_name_user_id_unique ON credentials (name, COALESCE(user_id, ''))`),
+        (db) => db.schema
+            .createTable('credentialsAudit')
+            .addColumn('id', 'varchar(36)', (col) => col.primaryKey())
+            .addColumn('credentialName', 'varchar(255)', (col) => col.notNull())
+            .addColumn('userId', 'varchar(255)')
+            .addColumn('action', 'varchar(20)', (col) => col.notNull())
+            .addColumn('performedAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull()),
+    ],
+};

package/dist/src/schema/deployment.schema.d.ts

@@ -0,0 +1,3 @@
+import type { PikkuSchema } from './pikku-schema.types.js';
+/** Registered deployments and the functions each one serves. */
+export declare const deploymentSchema: PikkuSchema;

package/dist/src/schema/deployment.schema.js

@@ -0,0 +1,32 @@
+import { sql } from 'kysely';
+/** Registered deployments and the functions each one serves. */
+export const deploymentSchema = {
+    name: 'deployment',
+    statements: [
+        (db) => db.schema
+            .createTable('pikkuDeployments')
+            .addColumn('deploymentId', 'text', (col) => col.primaryKey())
+            .addColumn('endpoint', 'text', (col) => col.notNull())
+            .addColumn('lastHeartbeat', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
+            .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull()),
+        (db) => db.schema
+            .createTable('pikkuDeploymentFunctions')
+            .addColumn('deploymentId', 'text', (col) => col
+            .notNull()
+            .references('pikkuDeployments.deploymentId')
+            .onDelete('cascade'))
+            .addColumn('functionName', 'text', (col) => col.notNull())
+            .addPrimaryKeyConstraint('pikku_deployment_functions_pk', [
+            'deploymentId',
+            'functionName',
+        ]),
+        (db) => db.schema
+            .createIndex('idx_pikku_deployments_heartbeat')
+            .on('pikkuDeployments')
+            .column('lastHeartbeat'),
+        (db) => db.schema
+            .createIndex('idx_pikku_deployment_functions_name')
+            .on('pikkuDeploymentFunctions')
+            .column('functionName'),
+    ],
+};

package/dist/src/schema/index.d.ts

@@ -0,0 +1,82 @@
+import { type Kysely } from 'kysely';
+import type { PikkuSchema, RequiredTypes, SchemaRequirement } from './pikku-schema.types.js';
+export type { PikkuSchema, RequiredTypes, SchemaRequirement, SchemaStatement, SchemaStatementFactory, } from './pikku-schema.types.js';
+export { rawStatement, requiredType } from './pikku-schema.types.js';
+/**
+ * Every table the pikku runtime needs, in dependency order.
+ *
+ * Order is load-bearing, not cosmetic: `scope` has foreign keys onto Better
+ * Auth's `user`, and the tables within each schema reference each other. Sort
+ * this list alphabetically and it stops applying.
+ */
+export declare const pikkuSchemas: PikkuSchema[];
+export interface UnmetRequirement {
+    schema: PikkuSchema;
+    requirement: SchemaRequirement;
+}
+/**
+ * Look up every prerequisite in `db`, reporting the gaps and the types found.
+ *
+ * Both halves come from one introspection because they are one question. The
+ * gaps say whether a schema can be applied at all; the types say how — a
+ * foreign key onto a `uuid` primary key has to be declared `uuid`, and guessing
+ * `text` produces DDL the database refuses.
+ *
+ * Introspection returns physical names, so `requires` is written in physical
+ * names too — this is the one place in the declaration that is not camelCase.
+ */
+export declare const resolveRequirements: (db: Kysely<any>, schemas?: PikkuSchema[]) => Promise<{
+    types: RequiredTypes;
+    unmet: UnmetRequirement[];
+}>;
+/**
+ * The prerequisites `db` does not satisfy, as a list rather than a throw.
+ *
+ * Separate from `applyPikkuSchemas` because the two callers want opposite
+ * things from the same answer: a service booting cannot proceed without its
+ * tables, while a tool asking what a project's schema *would* be needs to
+ * describe the gap rather than die on it.
+ */
+export declare const unsatisfiedRequirements: (db: Kysely<any>, schemas?: PikkuSchema[]) => Promise<UnmetRequirement[]>;
+/**
+ * Create the tables, in order, on a database that has whatever they require.
+ *
+ * Prerequisites are checked before anything is created, so a project missing
+ * one is told which schema wanted what — rather than being handed a foreign key
+ * error, or a half-applied database to clean up.
+ *
+ * The statements then run in one transaction, so the same promise holds for a
+ * failure the check cannot foresee: a statement that dies mid-list takes the
+ * ones before it with it. On an engine without transactional DDL the rollback
+ * is the engine's to give, not ours.
+ */
+export declare const applyPikkuSchemas: (db: Kysely<any>, schemas?: PikkuSchema[]) => Promise<void>;
+/** What `ensurePikkuSchema` found when it looked. */
+export type EnsureOutcome = 'present' | 'created';
+/**
+ * Make sure one schema's tables are there, creating them only if none are.
+ *
+ * What a service calls at boot. It looks before it creates, which is the whole
+ * difference from the `.ifNotExists()` DDL this replaces: that spelling turned
+ * every failure into a silent no-op, and hid a foreign key onto `user.id` that
+ * postgres had been rejecting since the day it was written.
+ *
+ * A partially-present schema is refused rather than completed. Half a schema
+ * means something else already applied part of it — a migration, an older
+ * version, a hand-run script — and creating the remainder at boot would leave
+ * two authorities over one set of tables, which is the condition all of this
+ * exists to end.
+ *
+ * Creating at boot is the fallback, not the intent. `pikku db generate` writes
+ * the declaration down as a migration; a project that has done so takes the
+ * `present` path and this never issues DDL at all.
+ */
+export declare const ensurePikkuSchema: (db: Kysely<any>, schema: PikkuSchema) => Promise<EnsureOutcome>;
+/**
+ * Render the declaration as SQL for the dialect `db` was built with.
+ *
+ * `types` comes from `resolveRequirements` against the database the migration
+ * is being written for. Omit it and foreign keys onto another source's columns
+ * compile as `text`, which is a shape, not a migration.
+ */
+export declare const compilePikkuSchemas: (db: Kysely<any>, schemas?: PikkuSchema[], types?: RequiredTypes) => string;