cogsbox-shape 0.5.192 → 0.5.194

package/README.md

@@ -33,35 +33,60 @@ Traditional approaches require defining these layers separately, leading to type
 Define a field by chaining methods. Each step is optional — use only what you need.
 
 ```
-s.sql()  →  .clientInput()  →  .client()  →  .server()  →  .transform()
+s.sqlite()/s.postgres()/s.mysql()  →  .clientInput()  →  .client()  →  .server()  →  .transform()
 ```
 
 | Method                            | Purpose                                                        |
 | --------------------------------- | -------------------------------------------------------------- |
-| `s.sql({ type, sqlOnly })`        | Database column type. `sqlOnly` excludes from client layer.    |
+| `s.sqlite/postgres/mysql({ type, sqlOnly })` | Database column type. `sqlOnly` excludes from client layer. |
 | `.clientInput({ value, schema })` | Client-side input schema and default value for new records.    |
 | `.client(fn)`                     | Client-side validation on the final client union type.         |
 | `.server(fn)`                     | Server-side validation. Stricter rules before database writes. |
 | `.transform({ toClient, toDb })`  | Converts between database and client representations.          |
 
-Note: `.derive()` is a schema-level method, not chainable on individual fields.
+Note: `.derive()` and `.refine()` are schema-level methods, not chainable on individual fields.
 
-### 1. SQL — Define Your Database Schema
-
-Start with your database reality:
+### 1. SQL — Define Your Database Schema
+
+Start with your database reality:
 
 ```typescript
 import { s, schema } from "cogsbox-shape";
 
 const userSchema = schema({
   _tableName: "users",
-  id: s.sql({ type: "int", pk: true }),
-  email: s.sql({ type: "varchar", length: 255 }),
-  createdAt: s.sql({ type: "datetime", default: "CURRENT_TIMESTAMP" }),
+  id: s.sqlite({ type: "int", pk: true }),
+  email: s.sqlite({ type: "varchar", length: 255 }),
+  createdAt: s.sqlite({ type: "datetime", default: "CURRENT_TIMESTAMP" }),
 });
 ```
 
-This generates a Zod schema matching your SQL types exactly.
+This generates a Zod schema matching your SQL types exactly.
+
+Use the SQL engine function that matches the database this schema targets:
+
+```typescript
+s.sqlite({ type: "text" });
+s.postgres({ type: "varchar", length: 255 });
+s.mysql({ type: "varchar", length: 255 });
+```
+
+Enums are real SQL column configs:
+
+```typescript
+s.sqlite({ type: "enum", values: ["draft", "published"] });
+// SQL: TEXT CHECK (...)
+
+s.postgres({
+  type: "enum",
+  name: "post_status",
+  values: ["draft", "published"],
+});
+// SQL: CREATE TYPE post_status AS ENUM (...), then column uses post_status
+
+s.mysql({ type: "enum", values: ["draft", "published"] });
+// SQL: ENUM('draft', 'published')
+```
 
 ### 2. Client Input — Defaults and Client-Side Validation
 
@@ -71,7 +96,7 @@ This generates a Zod schema matching your SQL types exactly.
 const userSchema = schema({
   _tableName: "users",
   // DB stores auto-increment integers, but new records need a temp string ID
-  id: s.sql({ type: "int", pk: true }).clientInput({
+  id: s.sqlite({ type: "int", pk: true }).clientInput({
     value: () => crypto.randomUUID(),
     schema: z.string(),
   }),
@@ -79,12 +104,12 @@ const userSchema = schema({
   // Default value: a generated UUID string
 
   // Simple default without type override
-  name: s.sql({ type: "varchar" }).clientInput({ value: "Anonymous" }),
+  name: s.sqlite({ type: "varchar" }).clientInput({ value: "Anonymous" }),
   // clientInput type: string (inherits from SQL)
   // Default value: "Anonymous"
 
   // Type-only override (no default value change)
-  count: s.sql({ type: "int" }).clientInput(() => z.number().min(0)),
+  count: s.sqlite({ type: "int" }).clientInput(() => z.number().min(0)),
   // clientInput type: number (with min validation)
   // Default value: inferred from type (0 for number)
 });
@@ -97,7 +122,7 @@ const userSchema = schema({
 `.client()` adds validation rules to the final `client` schema (the union of sql | clientInput). Use it for client-side validation that operates on the complete client type.
 
 ```typescript
-name: s.sql({ type: "varchar" })
+name: s.sqlite({ type: "varchar" })
   .clientInput({ value: "" })
   .client((tools) => tools.clientInput.min(3, "Too short"))
   .server((tools) => tools.clientInput.min(5, "Must be at least 5 chars")),
@@ -113,11 +138,11 @@ The `.client()` callback receives `tools` with `sql`, `clientInput`, and `client
 const userSchema = schema({
   _tableName: "users",
   email: s
-    .sql({ type: "varchar", length: 255 })
+    .sqlite({ type: "varchar", length: 255 })
     .server(({ sql }) => sql.email("Invalid email")),
 
   age: s
-    .sql({ type: "int" })
+    .sqlite({ type: "int" })
     .server(({ sql }) => sql.min(18, "Must be 18+").max(120)),
 });
 ```
@@ -126,7 +151,7 @@ The callback receives the previous schema in the chain so you can refine it:
 
 ```typescript
 name: s
-  .sql({ type: "varchar" })
+  .sqlite({ type: "varchar" })
   .clientInput(() => z.string().trim())
   .server(({ clientInput }) => clientInput.min(2, "Too short")),
 ```
@@ -137,7 +162,7 @@ name: s
 
 ```typescript
 status: s
-  .sql({ type: "int" })                              // DB: 0 or 1
+  .sqlite({ type: "int" })                              // DB: 0 or 1
   .clientInput(() => z.enum(["active", "inactive"])) // Client input: string enum
   .transform({
     toClient: (dbValue) => dbValue === 1 ? "active" : "inactive",
@@ -158,9 +183,9 @@ Use `sqlOnly: true` to define fields that belong to the database exclusively (li
 ```typescript
 const userSchema = schema({
   _tableName: "users",
-  id: s.sql({ type: "int", pk: true }),
-  email: s.sql({ type: "varchar" }),
-  internalToken: s.sql({ type: "varchar", sqlOnly: true }),
+  id: s.sqlite({ type: "int", pk: true }),
+  email: s.sqlite({ type: "varchar" }),
+  internalToken: s.sqlite({ type: "varchar", sqlOnly: true }),
 });
 // DB reads/writes: { id, email, internalToken }
 // Client sees: { id, email }
@@ -168,12 +193,12 @@ const userSchema = schema({
 
 #### Client-Only Fields
 
-By skipping `s.sql()` entirely and just using `s.clientInput()`, you can define fields that exist purely on the client (like a temporary UI state or computed field) and will not be sent to the database.
+By skipping `s.sqlite()` entirely and just using `s.clientInput()`, you can define fields that exist purely on the client (like a temporary UI state or computed field) and will not be sent to the database.
 
 ```typescript
 const products = schema({
   _tableName: "products",
-  price: s.sql({ type: "int" }),
+  price: s.sqlite({ type: "int" }),
   formattedPrice: s.clientInput(""), // Client-only field!
 });
 ```
@@ -188,14 +213,14 @@ const products = schema({
 ```typescript
 const users = schema({
   _tableName: "users",
-  firstName: s.sql({ type: "varchar" }).clientInput({ value: "John" }),
-  lastName: s.sql({ type: "varchar" }).clientInput({ value: "Doe" }),
+  firstName: s.sqlite({ type: "varchar" }).clientInput({ value: "John" }),
+  lastName: s.sqlite({ type: "varchar" }).clientInput({ value: "Doe" }),
 
   // Virtual field. It exists in app/view state, not SQL.
   fullName: s.clientInput(""),
 
   // Hidden DB column. It is written to SQL, but not sent to the client.
-  searchIndex: s.sql({ type: "varchar", sqlOnly: true }),
+  searchIndex: s.sqlite({ type: "varchar", sqlOnly: true }),
 }).derive({
   forClient: {
     fullName: (row) => `${row.firstName} ${row.lastName}`,
@@ -206,9 +231,71 @@ const users = schema({
 });
 ```
 
-During partial ORM updates, DB-backed derivations fetch only missing dependency fields they actually read, then recompute the affected `forDb` fields. Client-only derived fields are ignored by SQL writes.
+During partial ORM updates, DB-backed derivations fetch only missing dependency fields they actually read, then recompute the affected `forDb` fields. Client-only derived fields are ignored by SQL writes.
+
+### 7. Refinement (`.refine()`)
+
+`.refine()` adds cross-field validation rules that the entire row must satisfy. Unlike `.client()`/`.server()` which validate individual fields, `refine` can check relationships between fields.
+
+```typescript
+const events = schema({
+  _tableName: "events",
+  id: s.sqlite({ type: "int", pk: true }),
+  startDate: s.sqlite({ type: "varchar" }).clientInput({ value: "" }),
+  endDate: s.sqlite({ type: "varchar" }).clientInput({ value: "" }),
+  content: s.sqlite({ type: "varchar", nullable: true }).clientInput({
+    value: null,
+    schema: z.string().nullable(),
+  }),
+  isPublished: s.sqlite({ type: "boolean" }).clientInput({ value: false }),
+}).refine({
+  server: (row) => {
+    const errors: { path: string[]; message: string }[] = [];
+    if (row.startDate && row.endDate && row.startDate > row.endDate) {
+      errors.push({ path: ["endDate"], message: "End date must be after start date" });
+    }
+    if (row.isPublished && !row.content) {
+      errors.push({ path: ["content"], message: "Published events must have content" });
+    }
+    return errors.length > 0 ? errors : undefined;
+  },
+});
+
+const box = createSchemaBox({ events }, { events: {} });
+
+// Server refinement runs on parseForDb (before DB writes)
+box.events.transforms.parseForDb({
+  id: 1, startDate: "2024-12-31", endDate: "2024-01-01",
+  content: null, isPublished: false,
+});
+// Throws: "End date must be after start date"
+```
+
+The `refine()` config accepts two optional callbacks:
+
+| Callback | Runs on | Purpose |
+|----------|---------|---------|
+| `server` | `parseForDb()` | Cross-field validation before DB writes |
+| `client` | `clientInput` schema | Cross-field validation on client input |
+
+Each callback receives the full row and returns:
+- `undefined` or `null` — validation passes
+- A single `{ path: string[]; message: string }` — one error
+- An array of `{ path: string[]; message: string }` — multiple errors
+
+**Dependency tracking**: Same proxy-based approach as `derive()` — the library tracks which fields the refine function reads. This is used by the ORM to know which fields to include during partial updates. The same caveat applies: conditional branches with falsy defaults can hide dependencies.
+
+**Chaining**: `refine()` can be chained after `derive()`:
+
+```typescript
+schema({ ... })
+  .derive({ forDb: { fullName: (row) => `${row.firstName} ${row.lastName}` } })
+  .refine({ server: (row) => { ... } });
+```
+
+**Note**: `parsePatchForDb` uses the base schema (without refinement) since partial data may not satisfy cross-field rules.
 
-### Schema Object Structure
+### Schema Object Structure
 
 The returned schema object has a clear separation of concerns:
 
@@ -222,6 +309,8 @@ schema.generateDefaults; // Function to generate fresh defaults (executes random
 schema.pk; // Primary key field names
 schema.clientPk; // Client-side primary key field names
 schema.isClientRecord; // Function to check if a record is client-created
+schema.deriveDependencies; // Derive function dependencies ({ [field]: string[] })
+schema.refineDependencies; // Refinement dependencies ({ server: string[], client: string[] })
 ```
 
 ## Using Schemas
@@ -235,14 +324,14 @@ import { s, schema, createSchema } from "cogsbox-shape";
 
 const contactSchema = schema({
   _tableName: "contacts",
-  id: s.sql({ type: "int", pk: true }).clientInput({
+  id: s.sqlite({ type: "int", pk: true }).clientInput({
     value: () => `new_${crypto.randomUUID().slice(0, 8)}`,
     schema: z.string(),
   }),
-  name: s.sql({ type: "varchar" }).server(({ sql }) => sql.min(2)),
-  email: s.sql({ type: "varchar" }).server(({ sql }) => sql.email()),
+  name: s.sqlite({ type: "varchar" }).server(({ sql }) => sql.min(2)),
+  email: s.sqlite({ type: "varchar" }).server(({ sql }) => sql.email()),
   isActive: s
-    .sql({ type: "boolean", default: true })
+    .sqlite({ type: "boolean", default: true })
     .clientInput(() => z.boolean())
     .transform({
       toClient: (val) => Boolean(val),
@@ -282,15 +371,15 @@ import { s, schema, createSchemaBox } from "cogsbox-shape";
 
 const users = schema({
   _tableName: "users",
-  id: s.sql({ type: "int", pk: true }),
-  name: s.sql({ type: "varchar" }),
+  id: s.sqlite({ type: "int", pk: true }),
+  name: s.sqlite({ type: "varchar" }),
   posts: s.hasMany(), // Placeholder — resolved later
 });
 
 const posts = schema({
   _tableName: "posts",
-  id: s.sql({ type: "int", pk: true }),
-  title: s.sql({ type: "varchar" }),
+  id: s.sqlite({ type: "int", pk: true }),
+  title: s.sqlite({ type: "varchar" }),
   authorId: s.reference(() => users.id), // Foreign key
 });
 ```
@@ -364,7 +453,7 @@ const userView = bx.users.createView({
   posts: true,
 });
 
-const user = await userView.db.findById(1);
+const user = await userView.findById(1);
 // user.posts is loaded and validated as part of the view shape
 ```
 

package/cogsbox-shape-db/dist/connect.d.ts

@@ -1,11 +1,12 @@
 import { Kysely } from "kysely";
-import { TableDB } from "./table-db.js";
+import type { TableDBApi } from "./table-db.js";
 type FirstArg<T> = T extends (arg: infer A, ...args: any[]) => any ? A : never;
 type Return<T> = T extends (...args: any[]) => infer R ? R : never;
+type Row<T> = T extends readonly (infer TItem)[] ? TItem : T;
 type Prettify<T> = {
     [K in keyof T]: T[K];
 } & {};
-type SchemaMetaKey = "_tableName" | "__primaryKeySQL" | "__derives" | "primaryKeySQL" | "derive";
+type SchemaMetaKey = "_tableName" | "__primaryKeySQL" | "__derives" | "__refinements" | "primaryKeySQL" | "derive" | "refine";
 type SqlConfigOf<TField> = TField extends {
     config: {
         sql: infer TSql;
@@ -20,14 +21,14 @@ type SqlConfigBaseValue<TSql> = TSql extends {
 } ? number : TSql extends {
     type: "date" | "datetime" | "timestamp";
 } ? Date : TSql extends {
-    type: "varchar" | "char" | "text" | "longtext";
+    type: "varchar" | "char" | "text" | "longtext" | "enum";
 } ? string : unknown;
 type SqlOnlyValue<TField> = SqlConfigOf<TField> extends infer TSql ? TSql extends {
     nullable: true;
 } ? SqlConfigBaseValue<TSql> | null : SqlConfigBaseValue<TSql> : unknown;
 type IsSqlOnlyField<TField> = SqlConfigOf<TField> extends infer TSql ? TSql extends {
-    sqlOnly?: infer TSqlOnly;
-} ? true extends TSqlOnly ? true : false : false : false;
+    sqlOnly: true;
+} ? true : false : false;
 type IsOptionalSqlOnly<TField> = TField extends {
     config: {
         sql: {
@@ -47,27 +48,51 @@ type IsOptionalSqlOnly<TField> = TField extends {
         };
     };
 } ? true : false;
+type IsDerivedDbField<TTable, TKey> = TTable extends {
+    rawSchema: {
+        __derives?: {
+            forDb?: infer TForDb;
+        };
+    };
+} ? TKey extends keyof NonNullable<TForDb> ? true : false : false;
 type SqlOnlyInput<T> = T extends {
     definition: infer TDefinition;
 } ? Prettify<{
-    [K in keyof TDefinition as IsSqlOnlyField<TDefinition[K]> extends true ? K extends SchemaMetaKey ? never : IsOptionalSqlOnly<TDefinition[K]> extends true ? never : K : never]: SqlOnlyValue<TDefinition[K]>;
+    [K in keyof TDefinition as IsSqlOnlyField<TDefinition[K]> extends true ? K extends SchemaMetaKey ? never : TDefinition[K] extends {
+        __type: "reference";
+    } ? never : IsDerivedDbField<T, K> extends true ? never : IsOptionalSqlOnly<TDefinition[K]> extends true ? never : K : never]: SqlOnlyValue<TDefinition[K]>;
 } & {
-    [K in keyof TDefinition as IsSqlOnlyField<TDefinition[K]> extends true ? K extends SchemaMetaKey ? never : IsOptionalSqlOnly<TDefinition[K]> extends true ? K : never : never]?: SqlOnlyValue<TDefinition[K]>;
+    [K in keyof TDefinition as IsSqlOnlyField<TDefinition[K]> extends true ? K extends SchemaMetaKey ? never : TDefinition[K] extends {
+        __type: "reference";
+    } ? never : IsOptionalSqlOnly<TDefinition[K]> extends true ? K : never : never]?: SqlOnlyValue<TDefinition[K]>;
 }> : Record<string, never>;
+type DbApiFor<T> = T extends {
+    transforms: {
+        parseForDb: (...args: any[]) => any;
+        parseFromDb: (...args: any[]) => any;
+    };
+} ? TableDBApi<Row<Return<T["transforms"]["parseFromDb"]>>, Row<FirstArg<T["transforms"]["parseForDb"]>>, SqlOnlyInput<T>> : never;
+type ConnectedView<T> = T extends {
+    transforms: {
+        parseForDb: (...args: any[]) => any;
+        parseFromDb: (...args: any[]) => any;
+    };
+} ? Omit<T, keyof DbApiFor<T>> & DbApiFor<T> : T;
+type ConnectedCreateView<T> = T extends {
+    createView: (...args: infer TArgs) => infer TView;
+} ? {
+    createView: (...args: TArgs) => ConnectedView<TView>;
+} : {};
 type ConnectedTable<T> = T extends {
     transforms: {
         parseForDb: (...args: any[]) => any;
         parseFromDb: (...args: any[]) => any;
     };
-} ? T & {
-    db: TableDB<Return<T["transforms"]["parseFromDb"]>, FirstArg<T["transforms"]["parseForDb"]>, SqlOnlyInput<T>>;
-} : T;
+} ? Omit<T, "createView" | keyof DbApiFor<T>> & DbApiFor<T> & ConnectedCreateView<T> : T;
 type ConnectedBox<T extends Record<string, unknown>> = {
     [K in keyof T]: ConnectedTable<T[K]>;
 } & {
-    db: {
-        transaction: <R>(fn: (txBox: ConnectedBox<T>) => Promise<R>) => Promise<R>;
-    };
+    transaction: <R>(fn: (txBox: ConnectedBox<T>) => Promise<R>) => Promise<R>;
 };
-export declare function connect<T extends Record<string, unknown>>(box: T, db: Kysely<unknown>): ConnectedBox<T>;
+export declare function connect<T extends Record<string, unknown>>(box: T, db: Kysely<any>): ConnectedBox<T>;
 export {};

package/cogsbox-shape-db/dist/connect.js

@@ -91,8 +91,10 @@ function enhanceTable(entry, meta, db) {
     });
     return new Proxy(entry, {
         get(target, prop, receiver) {
-            if (prop === "db")
-                return tableDb;
+            if (prop in tableDb) {
+                const value = Reflect.get(tableDb, prop, tableDb);
+                return typeof value === "function" ? value.bind(tableDb) : value;
+            }
             return Reflect.get(target, prop, receiver);
         },
     });
@@ -208,8 +210,10 @@ export function connect(box, db) {
                     }, reconcile, hydrateRow);
                     return new Proxy(view, {
                         get(target, prop, receiver) {
-                            if (prop === "db")
-                                return viewDb;
+                            if (prop in viewDb) {
+                                const value = Reflect.get(viewDb, prop, viewDb);
+                                return typeof value === "function" ? value.bind(viewDb) : value;
+                            }
                             return Reflect.get(target, prop, receiver);
                         },
                     });
@@ -226,6 +230,6 @@ export function connect(box, db) {
             return fn(txBox);
         });
     };
-    result.db = { transaction };
+    result.transaction = transaction;
     return result;
 }

package/cogsbox-shape-db/dist/sqlite/sqlite-driver.d.ts

@@ -1,2 +1,2 @@
 import { Kysely } from "kysely";
-export declare function createSqliteDb(path: string): Promise<Kysely<unknown>>;
+export declare function createSqliteDb<TDb = unknown>(path: string): Promise<Kysely<TDb>>;

package/cogsbox-shape-db/dist/table-db.d.ts

@@ -5,13 +5,14 @@ type RequiredKeys<T> = {
     [K in keyof T]-?: Record<string, never> extends Pick<T, K> ? never : K;
 }[keyof T];
 type InsertDbOnlyArgs<T extends Record<string, unknown>> = keyof T extends never ? [] : RequiredKeys<T> extends never ? [dbOnlyData?: Partial<T>] : [dbOnlyData: T];
+export type TableDBApi<TClient extends Record<string, unknown>, TCreate, TDbOnly extends Record<string, unknown> = Record<string, never>> = Pick<TableDB<TClient, TCreate, TDbOnly>, "findMany" | "findById" | "byId" | "insert" | "create" | "update" | "delete" | "count" | "reconcileIds">;
 export declare class TableDB<TClient extends Record<string, unknown>, TCreate, TDbOnly extends Record<string, unknown> = Record<string, never>> {
     private db;
     private meta;
     private transforms;
     private reconcile?;
     private hydrateRow?;
-    constructor(db: Kysely<unknown>, meta: TableMeta, transforms: {
+    constructor(db: Kysely<any>, meta: TableMeta, transforms: {
         toClient: (row: Record<string, unknown>) => TClient;
         toDb: (row: Record<string, unknown>) => Record<string, unknown>;
         parseForDb: (data: Record<string, unknown>) => Record<string, unknown>;
@@ -22,6 +23,13 @@ export declare class TableDB<TClient extends Record<string, unknown>, TCreate, T
     }) | undefined, hydrateRow?: ((row: Record<string, unknown>) => Promise<Record<string, unknown>>) | undefined);
     findMany(opts?: FindManyOpts<TClient>): Promise<TClient[]>;
     findById(id: unknown): Promise<TClient | null>;
+    byId(id: unknown): {
+        find: () => Promise<TClient | null>;
+        update: (data: Partial<TCreate>, dbOnlyData?: DbOnlyArg<TDbOnly>) => ReturnType<TableDB<TClient, TCreate, TDbOnly>["update"]>;
+        delete: () => Promise<{
+            deleted: boolean;
+        }>;
+    };
     insert(data: TCreate, ...args: InsertDbOnlyArgs<TDbOnly>): {
         ids: () => Promise<Record<string, unknown>>;
         full: () => Promise<TClient>;
@@ -39,7 +47,7 @@ export declare class TableDB<TClient extends Record<string, unknown>, TCreate, T
     private pickDbPatchFields;
     private isWritableDbColumn;
     private parseDbOnlyData;
-    reconcileIds(clientData: unknown, ids: unknown): unknown;
+    reconcileIds<TData>(clientData: TData, ids: unknown): TData;
     private reconcileFlatIds;
     private mapIdsToClientFields;
     private clientKeyForDbField;

package/cogsbox-shape-db/dist/table-db.js

@@ -62,6 +62,13 @@ export class TableDB {
         const hydratedRow = this.hydrateRow ? await this.hydrateRow(row) : row;
         return this.transforms.parseFromDb(hydratedRow);
     }
+    byId(id) {
+        return {
+            find: () => this.findById(id),
+            update: (data, dbOnlyData) => this.update(id, data, dbOnlyData),
+            delete: () => this.delete(id),
+        };
+    }
     insert(data, ...args) {
         const dbOnlyData = args[0];
         return {

package/cogsbox-shape-db/dist/types.d.ts

@@ -1,14 +1,18 @@
-export type WhereValue<T> = T | {
-    contains?: string;
-    startsWith?: string;
-    endsWith?: string;
+type ComparableWhereValue<T> = {
     gt?: T;
     gte?: T;
     lt?: T;
     lte?: T;
-    in?: T[];
-    not?: T | Exclude<WhereValue<T>, T>;
 };
+type StringWhereValue<T> = Extract<T, string> extends never ? {} : {
+    contains?: string;
+    startsWith?: string;
+    endsWith?: string;
+};
+export type WhereValue<T> = T | ({
+    in?: Exclude<T, undefined>[];
+    not?: T;
+} & ComparableWhereValue<T> & StringWhereValue<T>);
 export type WhereInput<T> = {
     [K in keyof T]?: WhereValue<T[K]>;
 };
@@ -37,3 +41,4 @@ export interface TableMeta {
     sqlOnlyValidators: Map<string, (val: unknown) => unknown>;
     deriveDependencies: Map<string, string[]>;
 }
+export {};