@pikku/kysely 0.13.16 → 0.13.18

package/src/coercion-plugin.test.ts

@@ -0,0 +1,160 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert/strict'
+import type { QueryResult, UnknownRow } from 'kysely'
+import { createCoercionPlugin, type CoercionMap } from './coercion-plugin.js'
+
+function selectFrom(...tables: string[]) {
+  return {
+    kind: 'SelectQueryNode',
+    from: {
+      kind: 'FromNode',
+      froms: tables.map((table) => ({
+        kind: 'TableNode',
+        table: {
+          kind: 'SchemableIdentifierNode',
+          identifier: { kind: 'IdentifierNode', name: table },
+        },
+      })),
+    },
+  }
+}
+
+const runTransform = async (
+  map: CoercionMap,
+  rows: UnknownRow[],
+  node?: unknown
+): Promise<UnknownRow[]> => {
+  const plugin = createCoercionPlugin({ map })
+  const queryId = {} as { queryId: string }
+  if (node !== undefined) {
+    plugin.transformQuery({ node, queryId } as any)
+  }
+  const result = { rows } as QueryResult<UnknownRow>
+  const out = await plugin.transformResult({ result, queryId } as any)
+  return out.rows as UnknownRow[]
+}
+
+describe('createCoercionPlugin', () => {
+  test('transformQuery passes the node through untouched', () => {
+    const plugin = createCoercionPlugin({ map: {} })
+    const node = selectFrom('users') as any
+    assert.equal(
+      plugin.transformQuery({ node, queryId: { queryId: 'x' } } as any),
+      node
+    )
+  })
+
+  test('coerces date columns from ISO strings to Date', async () => {
+    const [row] = await runTransform({ users: { created_at: 'date' } }, [
+      { created_at: '2026-06-26T00:00:00.000Z' },
+    ])
+    assert.ok(row!.created_at instanceof Date)
+    assert.equal(
+      (row!.created_at as Date).toISOString(),
+      '2026-06-26T00:00:00.000Z'
+    )
+  })
+
+  test('leaves unparseable date strings untouched', async () => {
+    const [row] = await runTransform({ users: { created_at: 'date' } }, [
+      { created_at: 'not-a-date' },
+    ])
+    assert.equal(row!.created_at, 'not-a-date')
+  })
+
+  test('coerces bool columns from 0/1 numbers and bigints', async () => {
+    const rows = await runTransform(
+      { users: { is_active: 'bool', has_pets: 'bool' } },
+      [{ is_active: 1, has_pets: 0n }]
+    )
+    assert.equal(rows[0]!.is_active, true)
+    assert.equal(rows[0]!.has_pets, false)
+  })
+
+  test('parses json columns and tolerates invalid json', async () => {
+    const rows = await runTransform(
+      { users: { meta: 'json', broken: 'json' } },
+      [{ meta: '{"a":1}', broken: '{bad' }]
+    )
+    assert.deepEqual(rows[0]!.meta, { a: 1 })
+    assert.equal(rows[0]!.broken, '{bad')
+  })
+
+  test('passes through null values and unmapped columns', async () => {
+    const rows = await runTransform({ users: { created_at: 'date' } }, [
+      { created_at: null, name: 'leave me' },
+    ])
+    assert.equal(rows[0]!.created_at, null)
+    assert.equal(rows[0]!.name, 'leave me')
+  })
+
+  test('matches both snake_case and camelCase column names', async () => {
+    const rows = await runTransform({ users: { created_at: 'date' } }, [
+      { createdAt: '2026-06-26T00:00:00.000Z' },
+    ])
+    assert.ok(rows[0]!.createdAt instanceof Date)
+  })
+
+  test('leaves columns ambiguous across tables uncoerced', async () => {
+    const rows = await runTransform(
+      { users: { value: 'json' }, events: { value: 'bool' } },
+      [{ value: '{"a":1}' }]
+    )
+    assert.equal(rows[0]!.value, '{"a":1}')
+  })
+
+  test('still coerces columns that agree across tables', async () => {
+    const rows = await runTransform(
+      { users: { active: 'bool' }, events: { active: 'bool' } },
+      [{ active: 1 }]
+    )
+    assert.equal(rows[0]!.active, true)
+  })
+
+  test('uses table-qualified coercions when names collide', async () => {
+    const map: CoercionMap = {
+      users: { settings: 'json' },
+      posts: { settings: 'bool' },
+    }
+    const fromUsers = await runTransform(
+      map,
+      [{ settings: '{"theme":"dark"}' }],
+      selectFrom('users')
+    )
+    assert.deepEqual(fromUsers[0]!.settings, { theme: 'dark' })
+
+    const fromPosts = await runTransform(
+      map,
+      [{ settings: 1 }],
+      selectFrom('posts')
+    )
+    assert.equal(fromPosts[0]!.settings, true)
+  })
+
+  test('table-qualified lookup matches camelCase result columns too', async () => {
+    const rows = await runTransform(
+      { users: { created_at: 'date' }, jobs: { created_at: 'json' } },
+      [{ createdAt: '2026-06-26T00:00:00.000Z' }],
+      selectFrom('users')
+    )
+    assert.ok(rows[0]!.createdAt instanceof Date)
+  })
+
+  test('a join whose tables disagree leaves the column uncoerced', async () => {
+    const rows = await runTransform(
+      { users: { value: 'json' }, events: { value: 'bool' } },
+      [{ value: '{"a":1}' }],
+      selectFrom('users', 'events')
+    )
+    assert.equal(rows[0]!.value, '{"a":1}')
+  })
+
+  test('falls back to flat keys when the query names no known table', async () => {
+    const rows = await runTransform(
+      { users: { created_at: 'date' } },
+      [{ createdAt: '2026-01-02T03:04:05.000Z' }],
+      selectFrom('unrelated')
+    )
+    assert.ok(rows[0]!.createdAt instanceof Date)
+  })
+})

package/src/coercion-plugin.ts

@@ -0,0 +1,187 @@
+import type { KyselyPlugin, RootOperationNode, UnknownRow } from 'kysely'
+
+/**
+ * The kinds a column can be coerced *to* at runtime. This is the value type of
+ * the generated `CoercionMap`, so it is a public artifact contract — a kind may
+ * only appear here if `fromDb` below actually does something with it.
+ *
+ * `uuid` is deliberately absent: it is an annotation kind (it selects the `Uuid`
+ * TypeScript type in the generated schema) but not a coercion kind, and the
+ * codegen filters it out of `coercion.gen.ts` for exactly that reason — a UUID
+ * is a string in both Postgres and SQLite.
+ */
+export type ColumnKind = 'date' | 'bool' | 'json'
+
+/**
+ * Per-table column kind map. Keys are the table names queries are written
+ * against; inner keys are snake_case column names.
+ * Generated into `outDir/db/coercion.gen.ts` by `pikku db migrate` from the
+ * explicit `kind` entries in `db/annotations.ts`.
+ */
+export type CoercionMap = Record<string, Record<string, ColumnKind>>
+
+export interface CreateCoercionPluginOptions {
+  map: CoercionMap
+}
+
+function fromDb(value: unknown, kind: ColumnKind): unknown {
+  if (value == null) return value
+  switch (kind) {
+    case 'date':
+      if (typeof value === 'string') {
+        const d = new Date(value)
+        return Number.isNaN(d.getTime()) ? value : d
+      }
+      return value
+    case 'bool':
+      if (typeof value === 'number') return value !== 0
+      if (typeof value === 'bigint') return value !== 0n
+      return value
+    case 'json':
+      if (typeof value !== 'string') return value
+      try {
+        return JSON.parse(value)
+      } catch {
+        return value
+      }
+  }
+}
+
+function snakeToCamel(name: string): string {
+  return name.replace(/_([a-z])/g, (_, c) => c.toUpperCase())
+}
+
+interface ResolvedMaps {
+  /** `table.column` → kind, for the exact per-query resolution. */
+  qualified: Record<string, ColumnKind>
+  /** `column` → kind, the fallback for when the query's tables say nothing. */
+  flat: Record<string, ColumnKind>
+}
+
+/**
+ * Flatten the per-table map into a table-qualified lookup plus a bare
+ * column-name fallback. Both are indexed by BOTH snake_case and camelCase so
+ * they work regardless of CamelCasePlugin ordering in the plugin array.
+ *
+ * When two tables disagree on the kind for the same column name, the bare name
+ * is ambiguous (a joined/aliased query could carry either) and is dropped from
+ * the flat map rather than letting whichever table was processed last win. The
+ * qualified map still resolves it whenever the query names its tables.
+ */
+function buildMaps(map: CoercionMap): ResolvedMaps {
+  const qualified: Record<string, ColumnKind> = {}
+  const flat: Record<string, ColumnKind> = {}
+  const ambiguous = new Set<string>()
+  const assignFlat = (key: string, kind: ColumnKind) => {
+    const existing = flat[key]
+    if (existing !== undefined && existing !== kind) {
+      ambiguous.add(key)
+      return
+    }
+    flat[key] = kind
+  }
+  for (const [table, cols] of Object.entries(map)) {
+    for (const [col, kind] of Object.entries(cols)) {
+      const camel = snakeToCamel(col)
+      qualified[`${table}.${col}`] = kind
+      qualified[`${table}.${camel}`] = kind
+      assignFlat(col, kind)
+      assignFlat(camel, kind)
+    }
+  }
+  for (const key of ambiguous) delete flat[key]
+  return { qualified, flat }
+}
+
+/**
+ * Collect every table named anywhere in the query's operation node, so a result
+ * column can be resolved against the tables the query actually touched instead
+ * of against every table in the schema.
+ */
+function collectQueryTables(node: unknown, out: Set<string>): void {
+  if (!node || typeof node !== 'object') return
+
+  const op = node as {
+    kind?: string
+    table?: { identifier?: { name?: string } }
+  }
+  if (op.kind === 'TableNode') {
+    const tableName = op.table?.identifier?.name
+    if (typeof tableName === 'string' && tableName.length > 0)
+      out.add(tableName)
+  }
+
+  for (const value of Object.values(node)) {
+    if (Array.isArray(value)) {
+      for (const item of value) collectQueryTables(item, out)
+    } else {
+      collectQueryTables(value, out)
+    }
+  }
+}
+
+/**
+ * Resolve a result column's kind against the query's tables, falling back to
+ * the bare column name. Tables that disagree with each other are as ambiguous
+ * as two schema tables are, so they fall back too.
+ */
+function lookupKind(
+  maps: ResolvedMaps,
+  tables: readonly string[],
+  col: string
+): ColumnKind | undefined {
+  let matchedKind: ColumnKind | undefined
+  for (const table of tables) {
+    const kind = maps.qualified[`${table}.${col}`]
+    if (!kind) continue
+    if (matchedKind && matchedKind !== kind) return maps.flat[col]
+    matchedKind = kind
+  }
+  return matchedKind ?? maps.flat[col]
+}
+
+/**
+ * Convert values stored in a dialect's on-disk representation back into the
+ * logical types app code expects (Date / boolean / parsed JSON).
+ *
+ * SQLite is what makes this necessary — it stores dates as TEXT, booleans as
+ * INTEGER and JSON as TEXT — but the plugin is dialect-neutral: on Postgres the
+ * driver already returns Date/boolean/object, and every branch of `fromDb`
+ * passes a non-string, non-number value straight through. That is why it lives
+ * in `@pikku/kysely` next to `SerializePlugin` rather than in a SQLite package:
+ * the CLI installs it on its local Postgres database too.
+ *
+ * Write-side coercion (Date → ISO string, boolean → 0/1, object → JSON) is
+ * handled in the SQLite database adapters (always-on), so this plugin is
+ * read-only.
+ *
+ * Place AFTER CamelCasePlugin in the plugin array (or it handles both
+ * orderings via the dual-keyed maps).
+ */
+export function createCoercionPlugin(
+  options: CreateCoercionPluginOptions
+): KyselyPlugin {
+  const maps = buildMaps(options.map)
+  const queryTables = new WeakMap<object, readonly string[]>()
+  return {
+    transformQuery(args) {
+      const tables = new Set<string>()
+      collectQueryTables(args.node as RootOperationNode, tables)
+      queryTables.set(args.queryId, [...tables])
+      return args.node
+    },
+    async transformResult(args) {
+      const tables = queryTables.get(args.queryId) ?? []
+      const out: UnknownRow[] = []
+      for (const row of args.result.rows as UnknownRow[]) {
+        const next: UnknownRow = { ...row }
+        for (const [col, val] of Object.entries(row)) {
+          const kind = lookupKind(maps, tables, col)
+          if (kind) next[col] = fromDb(val, kind)
+        }
+        out.push(next)
+      }
+      return { ...args.result, rows: out }
+    },
+  }
+}

package/src/create-audited-kysely.test.ts

@@ -7,7 +7,7 @@ import {
   NoopAuditService,
   type AuditEvent,
   type AuditService,
-} from '../../../core/src/index.js'
+} from '@pikku/core/services'
 
 import { createAuditedKysely } from './create-audited-kysely.js'
 

package/src/create-audited-kysely.ts

@@ -1,4 +1,4 @@
-import type { AuditLog } from '@pikku/core'
+import type { AuditLog } from '@pikku/core/services'
 import type {
   Kysely,
   KyselyPlugin,

package/src/index.ts

@@ -25,6 +25,12 @@ export {
   type Serializer,
   type Deserializer,
 } from './serialize-plugin.js'
+export {
+  createCoercionPlugin,
+  type ColumnKind,
+  type CoercionMap,
+  type CreateCoercionPluginOptions,
+} from './coercion-plugin.js'
 export {
   auditSchema,
   pikkuSchemas,
@@ -40,12 +46,9 @@ export {
 } from './schema/index.js'
 
 export type { KyselyPikkuDB } from './kysely-tables.js'
-export type { WorkflowRunService } from '@pikku/core/ecosystem/workflow'
-export type {
-  AgentRunService,
-  AgentRunRow,
-} from '@pikku/core/ecosystem/agent'
+export type { WorkflowRunService } from '@pikku/core/workflow'
+export type { AgentRunService, AgentRunRow } from '@pikku/core/agent'
 export type {
   VirtualUserRunStore,
   VirtualUserRunRecord,
-} from '@pikku/core/ecosystem/virtual-user'
+} from '@pikku/core/virtual-user'

package/src/kysely-agent-run-scores.ts

@@ -1,7 +1,7 @@
 import type { Kysely } from 'kysely'
 import type { KyselyPikkuDB } from './kysely-tables.js'
-import type { SaveScoreInput } from '@pikku/core/services'
 import type { AgentRunScore } from '@pikku/core/agent-scorer'
+import type { SaveScoreInput } from '@pikku/core/services'
 import { parseJson } from './kysely-json.js'
 
 /**

package/src/kysely-agent-run-service.ts

@@ -1,8 +1,9 @@
-import type { AgentThread, AgentMessage } from '@pikku/core/agent'
 import type {
+  AgentThread,
+  AgentMessage,
   AgentRunRow,
   AgentRunService,
-} from '@pikku/core/ecosystem/agent'
+} from '@pikku/core/agent'
 import type { Kysely } from 'kysely'
 import { sql } from 'kysely'
 import type { KyselyPikkuDB } from './kysely-tables.js'

package/src/kysely-agent-run-state-service.ts

@@ -1,14 +1,14 @@
 import { sql } from 'kysely'
 import type { Kysely } from 'kysely'
 import type { KyselyPikkuDB } from './kysely-tables.js'
+import type { AgentRunState } from '@pikku/core/agent'
+import type { AgentRunScore } from '@pikku/core/agent-scorer'
 import type {
   AgentRunStateService,
   CreateRunInput,
   SaveScoreInput,
 } from '@pikku/core/services'
-import type { AgentRunState } from '@pikku/core/agent'
-import type { PendingApproval } from '@pikku/core/ecosystem/agent'
-import type { AgentRunScore } from '@pikku/core/agent-scorer'
+import type { PendingApproval } from '@pikku/core/agent'
 import { ensurePikkuSchema } from './schema/index.js'
 import { agentSchema } from './schema/agent.schema.js'
 import { getRunScores, saveRunScore } from './kysely-agent-run-scores.js'

package/src/kysely-agent-storage-service.ts

@@ -1,15 +1,15 @@
 import type {
-  AgentStorageService,
-  AgentRunStateService,
-  CreateRunInput,
-  SaveScoreInput,
-} from '@pikku/core/services'
-import type {
-  AgentThread,
   AgentMessage,
   AgentRunState,
+  AgentThread,
 } from '@pikku/core/agent'
 import type { AgentRunScore } from '@pikku/core/agent-scorer'
+import type {
+  AgentRunStateService,
+  AgentStorageService,
+  CreateRunInput,
+  SaveScoreInput,
+} from '@pikku/core/services'
 import type { Kysely } from 'kysely'
 import type { KyselyPikkuDB } from './kysely-tables.js'
 import { parseJson } from './kysely-json.js'

package/src/kysely-audit-service.test.ts

@@ -2,7 +2,7 @@ import { describe, test, beforeEach } from 'node:test'
 import assert from 'node:assert/strict'
 import Database from 'better-sqlite3'
 import { CamelCasePlugin, Kysely, SqliteDialect, sql } from 'kysely'
-import type { AuditEvent } from '../../../core/src/index.js'
+import type { AuditEvent } from '@pikku/core/services'
 
 import { KyselyAuditService } from './kysely-audit-service.js'
 

package/src/kysely-audit-service.ts

@@ -1,13 +1,10 @@
-import type { AuditService } from '@pikku/core'
-import type {
-  AuditEvent,
-  AuditEventBatch,
-} from '@pikku/core/ecosystem/services'
+import type { AuditService } from '@pikku/core/services'
+import type { AuditEvent, AuditEventBatch } from '@pikku/core/services'
 import type {
   AuditFacets,
   AuditQuery,
   AuditQueryResult,
-} from '@pikku/core/ecosystem/types'
+} from '@pikku/core/services'
 import type { Kysely } from 'kysely'
 import { ensurePikkuSchema } from './schema/index.js'
 import { auditSchema } from './schema/audit.schema.js'
@@ -118,8 +115,7 @@ export class KyselyAuditService implements AuditService {
     if (!batch.length) return
     const rows = batch.map((e) => {
       const metadata = e.metadata as
-        | { tables?: unknown; changedColumns?: unknown }
-        | undefined
+        { tables?: unknown; changedColumns?: unknown } | undefined
       return {
         audit_id: e.eventId ?? e.queryId ?? fallbackId(),
         occurred_at: e.occurredAt ?? new Date().toISOString(),

package/src/kysely-channel-store.ts

@@ -1,5 +1,5 @@
-import type { Channel } from '@pikku/core/channel'
 import { ChannelStore } from '@pikku/core/channel'
+import type { Channel } from '@pikku/core/channel'
 import type { Kysely } from 'kysely'
 import type { KyselyPikkuDB } from './kysely-tables.js'
 import { parseJson } from './kysely-json.js'

package/src/kysely-credential-service.ts

@@ -1,13 +1,13 @@
-import type { CredentialService } from '@pikku/core/services'
-import type { Kysely } from 'kysely'
-import type { KyselyPikkuDB } from './kysely-tables.js'
 import {
   deriveKEK,
-  generateKEKSalt,
-  envelopeEncrypt,
   envelopeDecrypt,
+  envelopeEncrypt,
   envelopeRewrap,
+  generateKEKSalt,
 } from '@pikku/core/crypto-utils'
+import type { CredentialService } from '@pikku/core/services'
+import type { Kysely } from 'kysely'
+import type { KyselyPikkuDB } from './kysely-tables.js'
 import { ensurePikkuSchema } from './schema/index.js'
 import { credentialSchema } from './schema/credential.schema.js'
 

package/src/kysely-deployment-service.ts

@@ -1,11 +1,12 @@
-import { buildRemoteHeaders } from '@pikku/core/ecosystem/remote'
+import { buildRemoteHeaders } from '@pikku/core/remote'
 import type {
   DeploymentService,
   DeploymentServiceConfig,
   DeploymentConfig,
-} from '@pikku/core/ecosystem/services'
-import type { JWTService, SecretService } from '@pikku/core/services'
-import { getAllFunctionNames } from '@pikku/core/ecosystem/function'
+} from '@pikku/core/services'
+import type { JWTService } from '@pikku/core/services'
+import type { SecretService } from '@pikku/core/services'
+import { getAllFunctionNames } from '@pikku/core/function'
 import type { Kysely } from 'kysely'
 import type { KyselyPikkuDB } from './kysely-tables.js'
 import { ensurePikkuSchema } from './schema/index.js'

package/src/kysely-eventhub-store.ts

@@ -1,4 +1,4 @@
-import { EventHubStore } from '@pikku/core/ecosystem/channel'
+import { EventHubStore } from '@pikku/core/channel'
 import type { Kysely } from 'kysely'
 import type { KyselyPikkuDB } from './kysely-tables.js'
 

package/src/kysely-scope-service.ts

@@ -1,7 +1,7 @@
 import type { ScopeService } from '@pikku/core/services'
-import type { Role } from '@pikku/core/ecosystem/services'
-import type { FlatScope } from '@pikku/core/ecosystem/scope'
-import type { SystemRole } from '@pikku/core/ecosystem/role'
+import type { Role } from '@pikku/core/services'
+import type { FlatScope } from '@pikku/core/scope'
+import type { SystemRole } from '@pikku/core/role'
 import {
   SystemRoleImmutableError,
   SystemRoleShadowedError,

package/src/kysely-secret-service.ts

@@ -1,14 +1,15 @@
-import { createSecretValue, isSecretValue, type SecretValue } from '@pikku/core'
-import type { SecretService, SecretValues } from '@pikku/core/services'
-import type { Kysely } from 'kysely'
-import type { KyselyPikkuDB } from './kysely-tables.js'
 import {
   deriveKEK,
-  generateKEKSalt,
-  envelopeEncrypt,
   envelopeDecrypt,
+  envelopeEncrypt,
   envelopeRewrap,
+  generateKEKSalt,
 } from '@pikku/core/crypto-utils'
+import { createSecretValue, isSecretValue } from '@pikku/core/classification'
+import type { SecretService, SecretValues } from '@pikku/core/services'
+import type { SecretValue } from '@pikku/core/classification'
+import type { Kysely } from 'kysely'
+import type { KyselyPikkuDB } from './kysely-tables.js'
 import { ensurePikkuSchema } from './schema/index.js'
 import { secretSchema } from './schema/secret.schema.js'
 

package/src/kysely-services.test.ts

@@ -5,7 +5,7 @@ import { SerializePlugin } from './serialize-plugin.js'
 import Database from 'better-sqlite3'
 import { PostgresJSDialect } from 'kysely-postgres-js'
 import postgres from 'postgres'
-import { defineServiceTests } from '@pikku/core/ecosystem/testing'
+import { defineServiceTests } from '@pikku/core/testing'
 
 import type { KyselyPikkuDB } from './kysely-tables.js'
 import { KyselyChannelStore } from './kysely-channel-store.js'

package/src/kysely-session-store.ts

@@ -1,5 +1,5 @@
-import type { CoreUserSession } from '@pikku/core'
 import type { SessionStore } from '@pikku/core/services'
+import type { CoreUserSession } from '@pikku/core/types'
 import type { Kysely } from 'kysely'
 import type { KyselyPikkuDB } from './kysely-tables.js'
 import { parseJson } from './kysely-json.js'

package/src/kysely-tables.ts

@@ -3,7 +3,7 @@ import type {
   WorkflowStatus,
   StepStatus,
   WorkflowVersionStatus,
-} from '@pikku/core/ecosystem/workflow'
+} from '@pikku/core/workflow'
 
 export interface ChannelsTable {
   channelId: string

package/src/kysely-virtual-user-run-store.ts

@@ -6,7 +6,7 @@ import type {
   VirtualUserRunRecord,
   VirtualUserRunStart,
   VirtualUserRunStore,
-} from '@pikku/core/ecosystem/virtual-user'
+} from '@pikku/core/virtual-user'
 import type { KyselyPikkuDB, VirtualUserRunTable } from './kysely-tables.js'
 import { parseJson } from './kysely-json.js'
 import { ensurePikkuSchema } from './schema/index.js'

package/src/kysely-webhook-service.test.ts

@@ -2,7 +2,7 @@ import { describe, test, beforeEach } from 'node:test'
 import assert from 'node:assert/strict'
 import { CamelCasePlugin, Kysely, SqliteDialect } from 'kysely'
 import Database from 'better-sqlite3'
-import { setSingletonServices } from '@pikku/core/ecosystem'
+import { setSingletonServices } from '@pikku/core/state'
 
 import type { KyselyPikkuDB } from './kysely-tables.js'
 import { SerializePlugin } from './serialize-plugin.js'

package/src/kysely-webhook-service.ts

@@ -1,4 +1,5 @@
 import { QueueWebhookService } from '@pikku/core/services'
+import type { QueueService } from '@pikku/core/queue'
 import {
   PIKKU_OUTGOING_WEBHOOK_QUEUE_NAME,
   type SendWebhookInput,
@@ -6,8 +7,7 @@ import {
   type WebhookAttemptResult,
   type WebhookDeliveryRecord,
   type WebhookDeliveryWithAttempts,
-} from '@pikku/core/ecosystem/services'
-import type { QueueService } from '@pikku/core/queue'
+} from '@pikku/core/services'
 import type { Kysely } from 'kysely'
 import type { KyselyPikkuDB } from './kysely-tables.js'
 import { ensurePikkuSchema } from './schema/index.js'

package/src/kysely-workflow-mirror.ts

@@ -1,4 +1,4 @@
-import type { SerializedError } from '@pikku/core/ecosystem/types'
+import type { SerializedError } from '@pikku/core/errors'
 import type {
   StepState,
   WorkflowRunMirror,
@@ -6,7 +6,7 @@ import type {
   WorkflowStatus,
   WorkflowPlannedStep,
   WorkflowVersionStatus,
-} from '@pikku/core/ecosystem/workflow'
+} from '@pikku/core/workflow'
 import type { Kysely } from 'kysely'
 import type { KyselyPikkuDB } from './kysely-tables.js'
 import { ensurePikkuSchema } from './schema/index.js'