@confect/server 9.0.0-next.8 → 9.0.0

package/dist/DatabaseReader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DatabaseReader.d.ts","names":[],"sources":["../src/DatabaseReader.ts"],"mappings":"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"}
+{"version":3,"file":"DatabaseReader.d.ts","sourceRoot":"","sources":["../src/DatabaseReader.ts"],"names":[],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAT,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqCxB,CAAC;AAEJ,MAAM,MAAM,cAAc,CACxB,eAAe,SAAS,cAAc,CAAC,YAAY,IACjD,UAAU,CAAC,OAAO,cAAc,CAAC,eAAe,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC;AAErE,eAAO,MAAM,KAAK,GAAI,eAAe,SAAS,cAAc,CAAC,YAAY,EACvE,gBAAgB,eAAe,EAC/B,sBAAsB,qBAAqB,CACzC,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC,CAC1D;kBA/Ce,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAoDxB,CAAC"}

package/dist/DatabaseSchema.d.ts

@@ -1,34 +1,31 @@
-import { AnyWithProps as AnyWithProps$1, Name, WithName } from "./Table.js";
-
-//#region src/DatabaseSchema.d.ts
-declare namespace DatabaseSchema_d_exports {
-  export { Any, AnyWithProps, DatabaseSchema, TableNames, TableWithName, Tables, TypeId, isDatabaseSchema, make };
+import type * as Table from "./Table";
+export declare const TypeId = "@confect/server/DatabaseSchema";
+export type TypeId = typeof TypeId;
+export interface Any {
+    readonly [TypeId]: TypeId;
 }
-declare const TypeId = "@confect/server/DatabaseSchema";
-type TypeId = typeof TypeId;
-interface Any {
-  readonly [TypeId]: TypeId;
-}
-declare const isDatabaseSchema: (u: unknown) => u is Any;
+export declare const isDatabaseSchema: (u: unknown) => u is Any;
 /**
  * A schema definition holding a record of bound `Table`s keyed by table
  * name. Codegen emits a single static `DatabaseSchema.make({ ... })` call;
- * laziness now lives entirely on each `Table` (its `Fields`, `Doc`, and
+ * laziness lives entirely on each `Table` (its `Fields`, `Doc`, and
  * `tableDefinition` are lazy memoised getters), so this layer is a plain
  * record indirection with no module-loading or async machinery.
  */
-interface DatabaseSchema<Tables_ extends AnyWithProps$1 = never> {
-  readonly [TypeId]: TypeId;
-  readonly tables: { readonly [TableName in Name<Tables_>]: WithName<Tables_, TableName> };
+export interface DatabaseSchema<Tables_ extends Table.AnyWithProps = never> {
+    readonly [TypeId]: TypeId;
+    readonly tables: {
+        readonly [TableName in Table.Name<Tables_>]: Table.WithName<Tables_, TableName>;
+    };
 }
-interface AnyWithProps {
-  readonly [TypeId]: TypeId;
-  readonly tables: Record<string, AnyWithProps$1>;
+export interface AnyWithProps {
+    readonly [TypeId]: TypeId;
+    readonly tables: Record<string, Table.AnyWithProps>;
 }
-type Tables<DatabaseSchema_ extends AnyWithProps> = DatabaseSchema_ extends DatabaseSchema<infer Tables_> ? Tables_ : never;
-type TableNames<DatabaseSchema_ extends AnyWithProps> = Name<Tables<DatabaseSchema_>> & string;
-type TableWithName<DatabaseSchema_ extends AnyWithProps, TableName extends TableNames<DatabaseSchema_>> = Extract<Tables<DatabaseSchema_>, {
-  readonly tableName: TableName;
+export type Tables<DatabaseSchema_ extends AnyWithProps> = DatabaseSchema_ extends DatabaseSchema<infer Tables_> ? Tables_ : never;
+export type TableNames<DatabaseSchema_ extends AnyWithProps> = Table.Name<Tables<DatabaseSchema_>> & string;
+export type TableWithName<DatabaseSchema_ extends AnyWithProps, TableName extends TableNames<DatabaseSchema_>> = Extract<Tables<DatabaseSchema_>, {
+    readonly tableName: TableName;
 }>;
 /**
  * Construct a `DatabaseSchema` from a record of bound `Table`s. The empty
@@ -46,7 +43,5 @@ type TableWithName<DatabaseSchema_ extends AnyWithProps, TableName extends Table
  * `{ notes, tags, users }` form it emits makes them identical by
  * construction). Hand-written calls must preserve it.
  */
-declare const make: <const TablesRecord extends Record<string, AnyWithProps$1>>(tables: TablesRecord) => DatabaseSchema<TablesRecord[keyof TablesRecord]>;
-//#endregion
-export { Any, AnyWithProps, DatabaseSchema, DatabaseSchema_d_exports, TableNames, TableWithName, Tables, TypeId, isDatabaseSchema, make };
+export declare const make: <const TablesRecord extends Record<string, Table.AnyWithProps>>(tables: TablesRecord) => DatabaseSchema<TablesRecord[keyof TablesRecord]>;
 //# sourceMappingURL=DatabaseSchema.d.ts.map

package/dist/DatabaseSchema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DatabaseSchema.d.ts","names":[],"sources":["../src/DatabaseSchema.ts"],"mappings":";;;;;;cAGa,MAAA;AAAA,KACD,MAAA,UAAgB,MAAA;AAAA,UAEX,GAAA;EAAA,UACL,MAAA,GAAS,MAAA;AAAA;AAAA,cAGR,gBAAA,GAAoB,CAAA,cAAa,CAAA,IAAK,GAAA;;;;;;;;UAUlC,cAAA,iBAA+B,cAAA;EAAA,UACpC,MAAA,GAAS,MAAA;EAAA,SACV,MAAA,2BACgB,IAAA,CAAW,OAAA,IAAW,QAAA,CAC3C,OAAA,EACA,SAAA;AAAA;AAAA,UAKW,YAAA;EAAA,UACL,MAAA,GAAS,MAAA;EAAA,SACV,MAAA,EAAQ,MAAA,SAAe,cAAA;AAAA;AAAA,KAGtB,MAAA,yBAA+B,YAAA,IACzC,eAAA,SAAwB,cAAA,kBAAgC,OAAA;AAAA,KAE9C,UAAA,yBAAmC,YAAA,IAAgB,IAAA,CAC7D,MAAA,CAAO,eAAA;AAAA,KAIG,aAAA,yBACc,YAAA,oBACN,UAAA,CAAW,eAAA,KAC3B,OAAA,CAAQ,MAAA,CAAO,eAAA;EAAA,SAA6B,SAAA,EAAW,SAAA;AAAA;;AApC3D;;;;;;;;;AAUA;;;;;;cA4Ca,IAAA,8BACgB,MAAA,SAAe,cAAA,GAE1C,MAAA,EAAQ,YAAA,KACP,cAAA,CAAe,YAAA,OAAmB,YAAA"}
+{"version":3,"file":"DatabaseSchema.d.ts","sourceRoot":"","sources":["../src/DatabaseSchema.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,KAAK,MAAM,SAAS,CAAC;AAEtC,eAAO,MAAM,MAAM,mCAAmC,CAAC;AACvD,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC;AAEnC,MAAM,WAAW,GAAG;IAClB,QAAQ,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,eAAO,MAAM,gBAAgB,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,GACjB,CAAC;AAEnC;;;;;;GAMG;AACH,MAAM,WAAW,cAAc,CAAC,OAAO,SAAS,KAAK,CAAC,YAAY,GAAG,KAAK;IACxE,QAAQ,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE;QACf,QAAQ,EAAE,SAAS,IAAI,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,KAAK,CAAC,QAAQ,CACzD,OAAO,EACP,SAAS,CACV;KACF,CAAC;CACH;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,YAAY,CAAC,CAAC;CACrD;AAED,MAAM,MAAM,MAAM,CAAC,eAAe,SAAS,YAAY,IACrD,eAAe,SAAS,cAAc,CAAC,MAAM,OAAO,CAAC,GAAG,OAAO,GAAG,KAAK,CAAC;AAE1E,MAAM,MAAM,UAAU,CAAC,eAAe,SAAS,YAAY,IAAI,KAAK,CAAC,IAAI,CACvE,MAAM,CAAC,eAAe,CAAC,CACxB,GACC,MAAM,CAAC;AAET,MAAM,MAAM,aAAa,CACvB,eAAe,SAAS,YAAY,EACpC,SAAS,SAAS,UAAU,CAAC,eAAe,CAAC,IAC3C,OAAO,CAAC,MAAM,CAAC,eAAe,CAAC,EAAE;IAAE,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAA;CAAE,CAAC,CAAC;AAExE;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,IAAI,GACf,KAAK,CAAC,YAAY,SAAS,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,YAAY,CAAC,EAE7D,QAAQ,YAAY,KACnB,cAAc,CAAC,YAAY,CAAC,MAAM,YAAY,CAAC,CAKhD,CAAC"}

package/dist/DatabaseSchema.js.map

@@ -1 +1 @@
-{"version":3,"file":"DatabaseSchema.js","names":[],"sources":["../src/DatabaseSchema.ts"],"sourcesContent":["import * as Predicate from \"effect/Predicate\";\nimport type * as Table from \"./Table\";\n\nexport const TypeId = \"@confect/server/DatabaseSchema\";\nexport type TypeId = typeof TypeId;\n\nexport interface Any {\n  readonly [TypeId]: TypeId;\n}\n\nexport const isDatabaseSchema = (u: unknown): u is Any =>\n  Predicate.hasProperty(u, TypeId);\n\n/**\n * A schema definition holding a record of bound `Table`s keyed by table\n * name. Codegen emits a single static `DatabaseSchema.make({ ... })` call;\n * laziness now lives entirely on each `Table` (its `Fields`, `Doc`, and\n * `tableDefinition` are lazy memoised getters), so this layer is a plain\n * record indirection with no module-loading or async machinery.\n */\nexport interface DatabaseSchema<Tables_ extends Table.AnyWithProps = never> {\n  readonly [TypeId]: TypeId;\n  readonly tables: {\n    readonly [TableName in Table.Name<Tables_>]: Table.WithName<\n      Tables_,\n      TableName\n    >;\n  };\n}\n\nexport interface AnyWithProps {\n  readonly [TypeId]: TypeId;\n  readonly tables: Record<string, Table.AnyWithProps>;\n}\n\nexport type Tables<DatabaseSchema_ extends AnyWithProps> =\n  DatabaseSchema_ extends DatabaseSchema<infer Tables_> ? Tables_ : never;\n\nexport type TableNames<DatabaseSchema_ extends AnyWithProps> = Table.Name<\n  Tables<DatabaseSchema_>\n> &\n  string;\n\nexport type TableWithName<\n  DatabaseSchema_ extends AnyWithProps,\n  TableName extends TableNames<DatabaseSchema_>,\n> = Extract<Tables<DatabaseSchema_>, { readonly tableName: TableName }>;\n\n/**\n * Construct a `DatabaseSchema` from a record of bound `Table`s. The empty\n * case is `DatabaseSchema.make({})`. The `Tables_` union is inferred from\n * the value record's values, so codegen-emitted calls of the form\n * `DatabaseSchema.make({ notes, tags, users })` do not need an explicit\n * type argument.\n *\n * Invariant: each record **key must equal its value's `tableName`**. The\n * record is stored verbatim and later read by key (`databaseSchema.tables[\n * tableName]` in `DatabaseReader`/`DatabaseWriter`), so a key that diverges\n * from the bound table's name would make those lookups silently miss. The\n * type signature does not enforce this — codegen upholds it by deriving both\n * the key and the table name from the same filename (and the shorthand\n * `{ notes, tags, users }` form it emits makes them identical by\n * construction). Hand-written calls must preserve it.\n */\nexport const make = <\n  const TablesRecord extends Record<string, Table.AnyWithProps>,\n>(\n  tables: TablesRecord,\n): DatabaseSchema<TablesRecord[keyof TablesRecord]> => ({\n  [TypeId]: TypeId,\n  tables: tables as unknown as DatabaseSchema<\n    TablesRecord[keyof TablesRecord]\n  >[\"tables\"],\n});\n"],"mappings":";;;;;;;;;AAGA,MAAa,SAAS;AAOtB,MAAa,oBAAoB,MAC/B,UAAU,YAAY,GAAG,OAAO;;;;;;;;;;;;;;;;;AAqDlC,MAAa,QAGX,YACsD;EACrD,SAAS;CACF;CAGT"}
+{"version":3,"file":"DatabaseSchema.js","names":[],"sources":["../src/DatabaseSchema.ts"],"sourcesContent":["import * as Predicate from \"effect/Predicate\";\nimport type * as Table from \"./Table\";\n\nexport const TypeId = \"@confect/server/DatabaseSchema\";\nexport type TypeId = typeof TypeId;\n\nexport interface Any {\n  readonly [TypeId]: TypeId;\n}\n\nexport const isDatabaseSchema = (u: unknown): u is Any =>\n  Predicate.hasProperty(u, TypeId);\n\n/**\n * A schema definition holding a record of bound `Table`s keyed by table\n * name. Codegen emits a single static `DatabaseSchema.make({ ... })` call;\n * laziness lives entirely on each `Table` (its `Fields`, `Doc`, and\n * `tableDefinition` are lazy memoised getters), so this layer is a plain\n * record indirection with no module-loading or async machinery.\n */\nexport interface DatabaseSchema<Tables_ extends Table.AnyWithProps = never> {\n  readonly [TypeId]: TypeId;\n  readonly tables: {\n    readonly [TableName in Table.Name<Tables_>]: Table.WithName<\n      Tables_,\n      TableName\n    >;\n  };\n}\n\nexport interface AnyWithProps {\n  readonly [TypeId]: TypeId;\n  readonly tables: Record<string, Table.AnyWithProps>;\n}\n\nexport type Tables<DatabaseSchema_ extends AnyWithProps> =\n  DatabaseSchema_ extends DatabaseSchema<infer Tables_> ? Tables_ : never;\n\nexport type TableNames<DatabaseSchema_ extends AnyWithProps> = Table.Name<\n  Tables<DatabaseSchema_>\n> &\n  string;\n\nexport type TableWithName<\n  DatabaseSchema_ extends AnyWithProps,\n  TableName extends TableNames<DatabaseSchema_>,\n> = Extract<Tables<DatabaseSchema_>, { readonly tableName: TableName }>;\n\n/**\n * Construct a `DatabaseSchema` from a record of bound `Table`s. The empty\n * case is `DatabaseSchema.make({})`. The `Tables_` union is inferred from\n * the value record's values, so codegen-emitted calls of the form\n * `DatabaseSchema.make({ notes, tags, users })` do not need an explicit\n * type argument.\n *\n * Invariant: each record **key must equal its value's `tableName`**. The\n * record is stored verbatim and later read by key (`databaseSchema.tables[\n * tableName]` in `DatabaseReader`/`DatabaseWriter`), so a key that diverges\n * from the bound table's name would make those lookups silently miss. The\n * type signature does not enforce this — codegen upholds it by deriving both\n * the key and the table name from the same filename (and the shorthand\n * `{ notes, tags, users }` form it emits makes them identical by\n * construction). Hand-written calls must preserve it.\n */\nexport const make = <\n  const TablesRecord extends Record<string, Table.AnyWithProps>,\n>(\n  tables: TablesRecord,\n): DatabaseSchema<TablesRecord[keyof TablesRecord]> => ({\n  [TypeId]: TypeId,\n  tables: tables as unknown as DatabaseSchema<\n    TablesRecord[keyof TablesRecord]\n  >[\"tables\"],\n});\n"],"mappings":";;;;;;;;;AAGA,MAAa,SAAS;AAOtB,MAAa,oBAAoB,MAC/B,UAAU,YAAY,GAAG,OAAO;;;;;;;;;;;;;;;;;AAqDlC,MAAa,QAGX,YACsD;EACrD,SAAS;CACF;CAGT"}

package/dist/DatabaseWriter.d.ts

@@ -1,49 +1,43 @@
-import { AnyWithProps } from "./DatabaseSchema.js";
-import { DocumentDecodeError, DocumentEncodeError, WithoutSystemFields as WithoutSystemFields$1 } from "./Document.js";
-import { DocumentByName, FromSchema, TableNames, ToConvex } from "./DataModel.js";
-import { GetByIdFailure } from "./QueryInitializer.js";
+import type { BetterOmit, Expand, GenericDatabaseWriter, WithoutSystemFields } from "convex/server";
+import type { GenericId } from "convex/values";
 import * as Context from "effect/Context";
-import { BetterOmit, Expand, GenericDatabaseWriter, WithoutSystemFields } from "convex/server";
-import * as Layer from "effect/Layer";
 import * as Effect from "effect/Effect";
-import { GenericId } from "convex/values";
-
-//#region src/DatabaseWriter.d.ts
-declare namespace DatabaseWriter_d_exports {
-  export { DatabaseWriter, layer, make };
-}
-declare const make: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: DatabaseSchema_, convexDatabaseWriter: GenericDatabaseWriter<ToConvex<FromSchema<DatabaseSchema_>>>) => {
-  table: <const TableName extends TableNames<FromSchema<DatabaseSchema_>>>(tableName: TableName) => {
-    insert: (document: WithoutSystemFields$1<DocumentByName<FromSchema<DatabaseSchema_>, TableName>>) => Effect.Effect<GenericId<TableName>, DocumentEncodeError, never>;
-    patch: (id: GenericId<TableName>, patchedValues: Partial<WithoutSystemFields<DocumentByName<FromSchema<DatabaseSchema_>, TableName>>>) => Effect.Effect<void, GetByIdFailure | DocumentDecodeError | DocumentEncodeError, never>;
-    replace: (id: GenericId<TableName>, value: WithoutSystemFields<DocumentByName<FromSchema<DatabaseSchema_>, TableName>>) => Effect.Effect<void, DocumentEncodeError, never>;
-    delete: (id: GenericId<TableName>) => Effect.Effect<void, never, never>;
-  };
+import * as Layer from "effect/Layer";
+import type * as DatabaseSchema from "./DatabaseSchema";
+import type * as DataModel from "./DataModel";
+import type { DocumentByName as DocumentByName_ } from "./DataModel";
+import * as Document from "./Document";
+import * as QueryInitializer from "./QueryInitializer";
+export declare const make: <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(databaseSchema: DatabaseSchema_, convexDatabaseWriter: GenericDatabaseWriter<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>>) => {
+    table: <const TableName extends DataModel.TableNames<DataModel.FromSchema<DatabaseSchema_>>>(tableName: TableName) => {
+        insert: (document: Document.WithoutSystemFields<DocumentByName_<DataModel.FromSchema<DatabaseSchema_>, TableName>>) => Effect.Effect<GenericId<TableName>, Document.DocumentEncodeError, never>;
+        patch: (id: GenericId<TableName>, patchedValues: Partial<WithoutSystemFields<DocumentByName_<DataModel.FromSchema<DatabaseSchema_>, TableName>>>) => Effect.Effect<void, Document.DocumentDecodeError | Document.DocumentEncodeError | QueryInitializer.GetByIdFailure, never>;
+        replace: (id: GenericId<TableName>, value: WithoutSystemFields<DocumentByName_<DataModel.FromSchema<DatabaseSchema_>, TableName>>) => Effect.Effect<void, Document.DocumentEncodeError, never>;
+        delete: (id: GenericId<TableName>) => Effect.Effect<void, never, never>;
+    };
 };
-declare const DatabaseWriter: <DatabaseSchema_ extends AnyWithProps>() => Context.Tag<{
-  table: <const TableName extends TableNames<FromSchema<DatabaseSchema_>>>(tableName: TableName) => {
-    insert: (document: WithoutSystemFields$1<DocumentByName<FromSchema<DatabaseSchema_>, TableName>>) => Effect.Effect<GenericId<TableName>, DocumentEncodeError, never>;
-    patch: (id: GenericId<TableName>, patchedValues: Partial<Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>>) => Effect.Effect<void, GetByIdFailure | DocumentDecodeError | DocumentEncodeError, never>;
-    replace: (id: GenericId<TableName>, value: Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>) => Effect.Effect<void, DocumentEncodeError, never>;
-    delete: (id: GenericId<TableName>) => Effect.Effect<void, never, never>;
-  };
+export declare const DatabaseWriter: <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>() => Context.Tag<{
+    table: <const TableName extends DataModel.TableNames<DataModel.FromSchema<DatabaseSchema_>>>(tableName: TableName) => {
+        insert: (document: Document.WithoutSystemFields<DataModel.DocumentByName<DataModel.FromSchema<DatabaseSchema_>, TableName>>) => Effect.Effect<GenericId<TableName>, Document.DocumentEncodeError, never>;
+        patch: (id: GenericId<TableName>, patchedValues: Partial<Expand<BetterOmit<DataModel.DocumentByName<DataModel.FromSchema<DatabaseSchema_>, TableName>, "_creationTime" | "_id">>>) => Effect.Effect<void, Document.DocumentDecodeError | Document.DocumentEncodeError | QueryInitializer.GetByIdFailure, never>;
+        replace: (id: GenericId<TableName>, value: Expand<BetterOmit<DataModel.DocumentByName<DataModel.FromSchema<DatabaseSchema_>, TableName>, "_creationTime" | "_id">>) => Effect.Effect<void, Document.DocumentEncodeError, never>;
+        delete: (id: GenericId<TableName>) => Effect.Effect<void, never, never>;
+    };
 }, {
-  table: <const TableName extends TableNames<FromSchema<DatabaseSchema_>>>(tableName: TableName) => {
-    insert: (document: WithoutSystemFields$1<DocumentByName<FromSchema<DatabaseSchema_>, TableName>>) => Effect.Effect<GenericId<TableName>, DocumentEncodeError, never>;
-    patch: (id: GenericId<TableName>, patchedValues: Partial<Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>>) => Effect.Effect<void, GetByIdFailure | DocumentDecodeError | DocumentEncodeError, never>;
-    replace: (id: GenericId<TableName>, value: Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>) => Effect.Effect<void, DocumentEncodeError, never>;
-    delete: (id: GenericId<TableName>) => Effect.Effect<void, never, never>;
-  };
+    table: <const TableName extends DataModel.TableNames<DataModel.FromSchema<DatabaseSchema_>>>(tableName: TableName) => {
+        insert: (document: Document.WithoutSystemFields<DataModel.DocumentByName<DataModel.FromSchema<DatabaseSchema_>, TableName>>) => Effect.Effect<GenericId<TableName>, Document.DocumentEncodeError, never>;
+        patch: (id: GenericId<TableName>, patchedValues: Partial<Expand<BetterOmit<DataModel.DocumentByName<DataModel.FromSchema<DatabaseSchema_>, TableName>, "_creationTime" | "_id">>>) => Effect.Effect<void, Document.DocumentDecodeError | Document.DocumentEncodeError | QueryInitializer.GetByIdFailure, never>;
+        replace: (id: GenericId<TableName>, value: Expand<BetterOmit<DataModel.DocumentByName<DataModel.FromSchema<DatabaseSchema_>, TableName>, "_creationTime" | "_id">>) => Effect.Effect<void, Document.DocumentEncodeError, never>;
+        delete: (id: GenericId<TableName>) => Effect.Effect<void, never, never>;
+    };
 }>;
-type DatabaseWriter<DatabaseSchema_ extends AnyWithProps> = ReturnType<typeof DatabaseWriter<DatabaseSchema_>>["Identifier"];
-declare const layer: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: DatabaseSchema_, convexDatabaseWriter: GenericDatabaseWriter<ToConvex<FromSchema<DatabaseSchema_>>>) => Layer.Layer<{
-  table: <const TableName extends TableNames<FromSchema<DatabaseSchema_>>>(tableName: TableName) => {
-    insert: (document: WithoutSystemFields$1<DocumentByName<FromSchema<DatabaseSchema_>, TableName>>) => Effect.Effect<GenericId<TableName>, DocumentEncodeError, never>;
-    patch: (id: GenericId<TableName>, patchedValues: Partial<Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>>) => Effect.Effect<void, GetByIdFailure | DocumentDecodeError | DocumentEncodeError, never>;
-    replace: (id: GenericId<TableName>, value: Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>) => Effect.Effect<void, DocumentEncodeError, never>;
-    delete: (id: GenericId<TableName>) => Effect.Effect<void, never, never>;
-  };
+export type DatabaseWriter<DatabaseSchema_ extends DatabaseSchema.AnyWithProps> = ReturnType<typeof DatabaseWriter<DatabaseSchema_>>["Identifier"];
+export declare const layer: <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(databaseSchema: DatabaseSchema_, convexDatabaseWriter: GenericDatabaseWriter<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>>) => Layer.Layer<{
+    table: <const TableName extends DataModel.TableNames<DataModel.FromSchema<DatabaseSchema_>>>(tableName: TableName) => {
+        insert: (document: Document.WithoutSystemFields<DataModel.DocumentByName<DataModel.FromSchema<DatabaseSchema_>, TableName>>) => Effect.Effect<GenericId<TableName>, Document.DocumentEncodeError, never>;
+        patch: (id: GenericId<TableName>, patchedValues: Partial<Expand<BetterOmit<DataModel.DocumentByName<DataModel.FromSchema<DatabaseSchema_>, TableName>, "_creationTime" | "_id">>>) => Effect.Effect<void, Document.DocumentDecodeError | Document.DocumentEncodeError | QueryInitializer.GetByIdFailure, never>;
+        replace: (id: GenericId<TableName>, value: Expand<BetterOmit<DataModel.DocumentByName<DataModel.FromSchema<DatabaseSchema_>, TableName>, "_creationTime" | "_id">>) => Effect.Effect<void, Document.DocumentEncodeError, never>;
+        delete: (id: GenericId<TableName>) => Effect.Effect<void, never, never>;
+    };
 }, never, never>;
-//#endregion
-export { DatabaseWriter, DatabaseWriter_d_exports, layer, make };
 //# sourceMappingURL=DatabaseWriter.d.ts.map

package/dist/DatabaseWriter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DatabaseWriter.d.ts","names":[],"sources":["../src/DatabaseWriter.ts"],"mappings":";;;;;;;;;;;;;;cAqBa,IAAA,2BAAgC,YAAA,EAC3C,cAAA,EAAgB,eAAA,EAChB,oBAAA,EAAsB,qBAAA,CACpB,QAAA,CAAmB,UAAA,CAAqB,eAAA;kCAKH,UAAA,CAAoB,UAAA,CAAA,eAAA,IAAY,SAAA,EAC1D,SAAA;uBAQC,qBAAA,CACR,cAAA,CAAe,UAAA,CAAA,eAAA,GAAa,SAAA,OAC7B,MAAA,CAAA,MAAA,CAAA,SAAA,CAAA,SAAA,GAAA,mBAAA;gBAsBG,SAAA,CAAU,SAAA,GAAU,aAAA,EACT,OAAA,CACb,mBAAA,CAAoB,cAAA,CAAe,UAAA,CAAA,eAAA,GAAa,SAAA,QACjD,MAAA,CAAA,MAAA,OAAA,cAAA,GAAA,mBAAA,GAAA,mBAAA;kBAqCG,SAAA,CAAU,SAAA,GAAU,KAAA,EACjB,mBAAA,CAAoB,cAAA,CAAe,UAAA,CAAA,eAAA,GAAa,SAAA,OAAW,MAAA,CAAA,MAAA,OAAA,mBAAA;iBAsB/C,SAAA,CAAU,SAAA,MAAU,MAAA,CAAA,MAAA;EAAA;AAAA;AAAA,cAgBhC,cAAA,2BACa,YAAA,OAA2B,OAAA,CAAA,GAAA;kCAjHrB,UAAA,CAAA,UAAA,CAAA,eAAA,IAAA,SAAA,EAAA,SAAA;;;;;;;kCAAA,UAAA,CAAA,UAAA,CAAA,eAAA,IAAA,SAAA,EAAA,SAAA;;;;;;;KAuHpB,cAAA,yBACc,YAAA,IACtB,UAAA,QAAkB,cAAA,CAAe,eAAA;AAAA,cAExB,KAAA,2BAAiC,YAAA,EAC5C,cAAA,EAAgB,eAAA,EAChB,oBAAA,EAAsB,qBAAA,CACpB,QAAA,CAAmB,UAAA,CAAqB,eAAA,QACzC,KAAA,CAAA,KAAA;kCA/H6B,UAAA,CAAA,UAAA,CAAA,eAAA,IAAA,SAAA,EAAA,SAAA"}
+{"version":3,"file":"DatabaseWriter.d.ts","sourceRoot":"","sources":["../src/DatabaseWriter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EAEV,MAAM,EACN,qBAAqB,EACrB,mBAAmB,EACpB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE/C,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,OAAO,KAAK,KAAK,cAAc,MAAM,kBAAkB,CAAC;AACxD,OAAO,KAAK,KAAK,SAAS,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,cAAc,IAAI,eAAe,EAAE,MAAM,aAAa,CAAC;AACrE,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,gBAAgB,MAAM,oBAAoB,CAAC;AAIvD,eAAO,MAAM,IAAI,GAAI,eAAe,SAAS,cAAc,CAAC,YAAY,EACtE,gBAAgB,eAAe,EAC/B,sBAAsB,qBAAqB,CACzC,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC,CAC1D;kBAIoB,SAAS,SAAS,SAAS,CAAC,UAAU,uCAAY,aAC1D,SAAS;2BAQR,QAAQ,CAAC,mBAAmB,CACpC,eAAe,wCAAa,SAAS,CAAC,CACvC;oBAsBG,SAAS,CAAC,SAAS,CAAC,iBACT,OAAO,CACpB,mBAAmB,CAAC,eAAe,wCAAa,SAAS,CAAC,CAAC,CAC5D;sBAqCG,SAAS,CAAC,SAAS,CAAC,SACjB,mBAAmB,CAAC,eAAe,wCAAa,SAAS,CAAC,CAAC;qBAsB/C,SAAS,CAAC,SAAS,CAAC;;CAc5C,CAAC;AAEF,eAAO,MAAM,cAAc,GACzB,eAAe,SAAS,cAAc,CAAC,YAAY;kBAjH9B,SAAS;;;;;;;kBAAT,SAAS;;;;;;EAqH7B,CAAC;AAEJ,MAAM,MAAM,cAAc,CACxB,eAAe,SAAS,cAAc,CAAC,YAAY,IACjD,UAAU,CAAC,OAAO,cAAc,CAAC,eAAe,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC;AAErE,eAAO,MAAM,KAAK,GAAI,eAAe,SAAS,cAAc,CAAC,YAAY,EACvE,gBAAgB,eAAe,EAC/B,sBAAsB,qBAAqB,CACzC,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC,CAC1D;kBA/HoB,SAAS;;;;;;gBAoI7B,CAAC"}

package/dist/Document.d.ts

@@ -1,48 +1,38 @@
-import { ReadonlyValue } from "./SchemaToValidator.js";
-import { TableSchema } from "./TableInfo.js";
-import { AnyWithProps, TableInfoWithName_, TableNames } from "./DataModel.js";
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
-import { ReadonlyRecord } from "effect/Record";
-
-//#region src/Document.d.ts
-declare namespace Document_d_exports {
-  export { Any, AnyEncoded, DocumentDecodeError, DocumentEncodeError, WithoutSystemFields, decode, documentErrorMessage, encode };
-}
-type WithoutSystemFields<Doc> = Omit<Doc, "_creationTime" | "_id">;
-type Any = any;
-type AnyEncoded = ReadonlyRecord<string, ReadonlyValue>;
-declare const decode: (<DataModel_ extends AnyWithProps, TableName extends TableNames<DataModel_>>(tableName: TableName, tableSchema: TableSchema<TableInfoWithName_<DataModel_, TableName>>) => (self: TableInfoWithName_<DataModel_, TableName>["convexDocument"]) => Effect.Effect<TableInfoWithName_<DataModel_, TableName>["document"], DocumentDecodeError>) & (<DataModel_ extends AnyWithProps, TableName extends TableNames<DataModel_>>(self: TableInfoWithName_<DataModel_, TableName>["convexDocument"], tableName: TableName, tableSchema: TableSchema<TableInfoWithName_<DataModel_, TableName>>) => Effect.Effect<TableInfoWithName_<DataModel_, TableName>["document"], DocumentDecodeError>);
-declare const encode: (<DataModel_ extends AnyWithProps, TableName extends TableNames<DataModel_>>(tableName: TableName, tableSchema: TableSchema<TableInfoWithName_<DataModel_, TableName>>) => (self: TableInfoWithName_<DataModel_, TableName>["document"]) => Effect.Effect<TableInfoWithName_<DataModel_, TableName>["encodedDocument"], DocumentEncodeError>) & (<DataModel_ extends AnyWithProps, TableName extends TableNames<DataModel_>>(self: TableInfoWithName_<DataModel_, TableName>["document"], tableName: TableName, tableSchema: TableSchema<TableInfoWithName_<DataModel_, TableName>>) => Effect.Effect<TableInfoWithName_<DataModel_, TableName>["encodedDocument"], DocumentEncodeError>);
+import type { ReadonlyRecord } from "effect/Record";
+import type * as DataModel from "./DataModel";
+import type { ReadonlyValue } from "./SchemaToValidator";
+import type * as TableInfo from "./TableInfo";
+export type WithoutSystemFields<Doc> = Omit<Doc, "_creationTime" | "_id">;
+export type Any = any;
+export type AnyEncoded = ReadonlyRecord<string, ReadonlyValue>;
+export declare const decode: (<DataModel_ extends DataModel.AnyWithProps, TableName extends DataModel.TableNames<DataModel_>>(tableName: TableName, tableSchema: TableInfo.TableSchema<DataModel.TableInfoWithName_<DataModel_, TableName>>) => (self: DataModel.TableInfoWithName_<DataModel_, TableName>["convexDocument"]) => Effect.Effect<DataModel.TableInfoWithName_<DataModel_, TableName>["document"], DocumentDecodeError>) & (<DataModel_ extends DataModel.AnyWithProps, TableName extends DataModel.TableNames<DataModel_>>(self: DataModel.TableInfoWithName_<DataModel_, TableName>["convexDocument"], tableName: TableName, tableSchema: TableInfo.TableSchema<DataModel.TableInfoWithName_<DataModel_, TableName>>) => Effect.Effect<DataModel.TableInfoWithName_<DataModel_, TableName>["document"], DocumentDecodeError>);
+export declare const encode: (<DataModel_ extends DataModel.AnyWithProps, TableName extends DataModel.TableNames<DataModel_>>(tableName: TableName, tableSchema: TableInfo.TableSchema<DataModel.TableInfoWithName_<DataModel_, TableName>>) => (self: DataModel.TableInfoWithName_<DataModel_, TableName>["document"]) => Effect.Effect<DataModel.TableInfoWithName_<DataModel_, TableName>["encodedDocument"], DocumentEncodeError>) & (<DataModel_ extends DataModel.AnyWithProps, TableName extends DataModel.TableNames<DataModel_>>(self: DataModel.TableInfoWithName_<DataModel_, TableName>["document"], tableName: TableName, tableSchema: TableInfo.TableSchema<DataModel.TableInfoWithName_<DataModel_, TableName>>) => Effect.Effect<DataModel.TableInfoWithName_<DataModel_, TableName>["encodedDocument"], DocumentEncodeError>);
 declare const DocumentDecodeError_base: Schema.TaggedErrorClass<DocumentDecodeError, "DocumentDecodeError", {
-  readonly _tag: Schema.tag<"DocumentDecodeError">;
+    readonly _tag: Schema.tag<"DocumentDecodeError">;
 } & {
-  tableName: typeof Schema.String;
-  id: typeof Schema.String;
-  parseError: typeof Schema.String;
+    tableName: typeof Schema.String;
+    id: typeof Schema.String;
+    parseError: typeof Schema.String;
 }>;
-declare class DocumentDecodeError extends DocumentDecodeError_base {
-  get message(): string;
+export declare class DocumentDecodeError extends DocumentDecodeError_base {
+    get message(): string;
 }
 declare const DocumentEncodeError_base: Schema.TaggedErrorClass<DocumentEncodeError, "DocumentEncodeError", {
-  readonly _tag: Schema.tag<"DocumentEncodeError">;
+    readonly _tag: Schema.tag<"DocumentEncodeError">;
 } & {
-  tableName: typeof Schema.String;
-  id: typeof Schema.String;
-  parseError: typeof Schema.String;
+    tableName: typeof Schema.String;
+    id: typeof Schema.String;
+    parseError: typeof Schema.String;
 }>;
-declare class DocumentEncodeError extends DocumentEncodeError_base {
-  get message(): string;
+export declare class DocumentEncodeError extends DocumentEncodeError_base {
+    get message(): string;
 }
-declare const documentErrorMessage: ({
-  id,
-  tableName,
-  message
-}: {
-  id: string;
-  tableName: string;
-  message: string;
+export declare const documentErrorMessage: ({ id, tableName, message, }: {
+    id: string;
+    tableName: string;
+    message: string;
 }) => string;
-//#endregion
-export { Any, AnyEncoded, DocumentDecodeError, DocumentEncodeError, Document_d_exports, WithoutSystemFields, decode, documentErrorMessage, encode };
+export {};
 //# sourceMappingURL=Document.d.ts.map

package/dist/Document.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Document.d.ts","names":[],"sources":["../src/Document.ts"],"mappings":";;;;;;;;;;;KAWY,mBAAA,QAA2B,IAAA,CAAK,GAAA;AAAA,KAEhC,GAAA;AAAA,KACA,UAAA,GAAa,cAAA,SAAuB,aAAA;AAAA,cAiCnC,MAAA,uBAEU,YAAA,oBACD,UAAA,CAAqB,UAAA,GAAW,SAAA,EAEvC,SAAA,EAAS,WAAA,EACP,WAAA,CACX,kBAAA,CAA6B,UAAA,EAAY,SAAA,QAG3C,IAAA,EAAM,kBAAA,CAA6B,UAAA,EAAY,SAAA,wBAC5C,MAAA,CAAO,MAAA,CACV,kBAAA,CAA6B,UAAA,EAAY,SAAA,eACzC,mBAAA,0BAGmB,YAAA,oBACD,UAAA,CAAqB,UAAA,GAAW,IAAA,EAE5C,kBAAA,CAA6B,UAAA,EAAY,SAAA,qBAA4B,SAAA,EAChE,SAAA,EAAS,WAAA,EACP,WAAA,CACX,kBAAA,CAA6B,UAAA,EAAY,SAAA,OAExC,MAAA,CAAO,MAAA,CACV,kBAAA,CAA6B,UAAA,EAAY,SAAA,eACzC,mBAAA;AAAA,cAsDS,MAAA,uBAEU,YAAA,oBACD,UAAA,CAAqB,UAAA,GAAW,SAAA,EAEvC,SAAA,EAAS,WAAA,EACP,WAAA,CACX,kBAAA,CAA6B,UAAA,EAAY,SAAA,QAG3C,IAAA,EAAM,kBAAA,CAA6B,UAAA,EAAY,SAAA,kBAC5C,MAAA,CAAO,MAAA,CACV,kBAAA,CAA6B,UAAA,EAAY,SAAA,sBACzC,mBAAA,0BAGmB,YAAA,oBACD,UAAA,CAAqB,UAAA,GAAW,IAAA,EAE5C,kBAAA,CAA6B,UAAA,EAAY,SAAA,eAAsB,SAAA,EAC1D,SAAA,EAAS,WAAA,EACP,WAAA,CACX,kBAAA,CAA6B,UAAA,EAAY,SAAA,OAExC,MAAA,CAAO,MAAA,CACV,kBAAA,CAA6B,UAAA,EAAY,SAAA,sBACzC,mBAAA;AAAA,cAwCF,wBAAA;;;;;;;cAEW,mBAAA,SAA4B,wBAAA;EAAA,IAQ1B,OAAA,CAAA;AAAA;AAAA,cAOd,wBAAA;;;;;;;cAEY,mBAAA,SAA4B,wBAAA;EAAA,IAQ1B,OAAA,CAAA;AAAA;AAAA,cASF,oBAAA;EAAwB,EAAA;EAAA,SAAA;EAAA;AAAA;EAKnC,EAAA;EACA,SAAA;EACA,OAAA;AAAA"}
+{"version":3,"file":"Document.d.ts","sourceRoot":"","sources":["../src/Document.ts"],"names":[],"mappings":"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"}

package/dist/FunctionImpl.d.ts

@@ -1,21 +1,14 @@
-import { AnyWithProps } from "./DatabaseSchema.js";
-import { WithName } from "./Handler.js";
+import type * as FunctionSpec from "@confect/core/FunctionSpec";
+import type * as GroupSpec from "@confect/core/GroupSpec";
 import * as Context from "effect/Context";
 import * as Layer from "effect/Layer";
-import * as FunctionSpec from "@confect/core/FunctionSpec";
-import * as GroupSpec from "@confect/core/GroupSpec";
-
-//#region src/FunctionImpl.d.ts
-declare namespace FunctionImpl_d_exports {
-  export { ForFunction, FromGroupSpec, FunctionImpl, make };
+import type * as DatabaseSchema from "./DatabaseSchema";
+import type * as Handler from "./Handler";
+export interface FunctionImpl<FunctionName extends string> {
+    readonly functionName: FunctionName;
 }
-interface FunctionImpl<FunctionName extends string> {
-  readonly functionName: FunctionName;
-}
-declare const FunctionImpl: <FunctionName extends string>({
-  functionName
-}: {
-  functionName: FunctionName;
+export declare const FunctionImpl: <FunctionName extends string>({ functionName, }: {
+    functionName: FunctionName;
 }) => Context.Tag<FunctionImpl<FunctionName>, FunctionImpl<FunctionName>>;
 /**
  * Register a single function's implementation into the group's `Registry`.
@@ -33,15 +26,13 @@ declare const FunctionImpl: <FunctionName extends string>({
  * builders — so impls depend on `_generated/schema` (table schemas) rather than
  * `_generated/api` (which transitively imports every function spec).
  */
-declare const make: <DatabaseSchema_ extends AnyWithProps, Group extends GroupSpec.AnyWithProps, const FunctionName extends FunctionSpec.Name<GroupSpec.Functions<Group>>>(_databaseSchema: DatabaseSchema_, group: Group, functionName: FunctionName, handler: WithName<DatabaseSchema_, GroupSpec.Functions<Group>, FunctionName>) => Layer.Layer<FunctionImpl<FunctionName>>;
+export declare const make: <DatabaseSchema_ extends DatabaseSchema.AnyWithProps, Group extends GroupSpec.AnyWithProps, const FunctionName extends FunctionSpec.Name<GroupSpec.Functions<Group>>>(_databaseSchema: DatabaseSchema_, group: Group, functionName: FunctionName, handler: Handler.WithName<DatabaseSchema_, GroupSpec.Functions<Group>, FunctionName>) => Layer.Layer<FunctionImpl<FunctionName>>;
 /**
  * Get the function implementation service type for a specific function name.
  */
-type ForFunction<FunctionName extends string> = FunctionImpl<FunctionName>;
+export type ForFunction<FunctionName extends string> = FunctionImpl<FunctionName>;
 /**
  * Get all function implementation services required for a group spec.
  */
-type FromGroupSpec<Group extends GroupSpec.AnyWithProps> = FunctionSpec.Name<GroupSpec.Functions<Group>> extends infer FunctionNames extends string ? FunctionNames extends string ? FunctionImpl<FunctionNames> : never : never;
-//#endregion
-export { ForFunction, FromGroupSpec, FunctionImpl, FunctionImpl_d_exports, make };
+export type FromGroupSpec<Group extends GroupSpec.AnyWithProps> = FunctionSpec.Name<GroupSpec.Functions<Group>> extends infer FunctionNames extends string ? FunctionNames extends string ? FunctionImpl<FunctionNames> : never : never;
 //# sourceMappingURL=FunctionImpl.d.ts.map

package/dist/FunctionImpl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FunctionImpl.d.ts","names":[],"sources":["../src/FunctionImpl.ts"],"mappings":";;;;;;;;;;;UAYiB,YAAA;EAAA,SACN,YAAA,EAAc,YAAA;AAAA;AAAA,cAGZ,YAAA;EAA6C;AAAA;EAGxD,YAAA,EAAc,YAAA;AAAA,MACf,OAAA,CAAA,GAAA,CAAA,YAAA,CAAA,YAAA,GAAA,YAAA,CAAA,YAAA;;;;AARD;;;;;;;;;AAIA;;;;cAyBa,IAAA,2BACa,YAAA,gBACV,SAAA,CAAU,YAAA,6BACG,YAAA,CAAa,IAAA,CAAK,SAAA,CAAU,SAAA,CAAU,KAAA,IAEjE,eAAA,EAAiB,eAAA,EACjB,KAAA,EAAO,KAAA,EACP,YAAA,EAAc,YAAA,EACd,OAAA,EAAS,QAAA,CACP,eAAA,EACA,SAAA,CAAU,SAAA,CAAU,KAAA,GACpB,YAAA,MAED,KAAA,CAAM,KAAA,CAAM,YAAA,CAAa,YAAA;;;;KA2BhB,WAAA,gCACV,YAAA,CAAa,YAAA;;;;KAKH,aAAA,eAA4B,SAAA,CAAU,YAAA,IAChD,YAAA,CAAa,IAAA,CACX,SAAA,CAAU,SAAA,CAAU,KAAA,gDAElB,aAAA,kBACE,YAAA,CAAa,aAAA"}
+{"version":3,"file":"FunctionImpl.d.ts","sourceRoot":"","sources":["../src/FunctionImpl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,YAAY,MAAM,4BAA4B,CAAC;AAChE,OAAO,KAAK,KAAK,SAAS,MAAM,yBAAyB,CAAC;AAE1D,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAE1C,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,OAAO,KAAK,KAAK,cAAc,MAAM,kBAAkB,CAAC;AACxD,OAAO,KAAK,KAAK,OAAO,MAAM,WAAW,CAAC;AAI1C,MAAM,WAAW,YAAY,CAAC,YAAY,SAAS,MAAM;IACvD,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC;CACrC;AAED,eAAO,MAAM,YAAY,GAAI,YAAY,SAAS,MAAM,EAAE,mBAEvD;IACD,YAAY,EAAE,YAAY,CAAC;CAC5B,wEAGE,CAAC;AAEJ;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,IAAI,GACf,eAAe,SAAS,cAAc,CAAC,YAAY,EACnD,KAAK,SAAS,SAAS,CAAC,YAAY,EACpC,KAAK,CAAC,YAAY,SAAS,YAAY,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,EAExE,iBAAiB,eAAe,EAChC,OAAO,KAAK,EACZ,cAAc,YAAY,EAC1B,SAAS,OAAO,CAAC,QAAQ,CACvB,eAAe,EACf,SAAS,CAAC,SAAS,CAAC,KAAK,CAAC,EAC1B,YAAY,CACb,KACA,KAAK,CAAC,KAAK,CAAC,YAAY,CAAC,YAAY,CAAC,CAsBxC,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,WAAW,CAAC,YAAY,SAAS,MAAM,IACjD,YAAY,CAAC,YAAY,CAAC,CAAC;AAE7B;;GAEG;AACH,MAAM,MAAM,aAAa,CAAC,KAAK,SAAS,SAAS,CAAC,YAAY,IAC5D,YAAY,CAAC,IAAI,CACf,SAAS,CAAC,SAAS,CAAC,KAAK,CAAC,CAC3B,SAAS,MAAM,aAAa,SAAS,MAAM,GACxC,aAAa,SAAS,MAAM,GAC1B,YAAY,CAAC,aAAa,CAAC,GAC3B,KAAK,GACP,KAAK,CAAC"}

package/dist/GroupImpl.d.ts

@@ -1,33 +1,31 @@
-import { AnyWithProps } from "./DatabaseSchema.js";
-import { FromGroupSpec as FromGroupSpec$1 } from "./FunctionImpl.js";
+import type * as GroupSpec from "@confect/core/GroupSpec";
 import * as Context from "effect/Context";
 import * as Layer from "effect/Layer";
-import * as GroupSpec from "@confect/core/GroupSpec";
-
-//#region src/GroupImpl.d.ts
-declare namespace GroupImpl_d_exports {
-  export { Any, AnyFinalized, AnyUnfinalized, FinalizationStatus, FromGroupSpec, GroupImpl, TypeId, finalize, isFinalizedGroupImpl, isGroupImpl, isUnfinalizedGroupImpl, make };
+import type * as DatabaseSchema from "./DatabaseSchema";
+import type * as FunctionImpl from "./FunctionImpl";
+export declare const TypeId = "@confect/server/GroupImpl";
+export type TypeId = typeof TypeId;
+export type FinalizationStatus = "Unfinalized" | "Finalized";
+export interface GroupImpl<FinalizationStatus_ extends FinalizationStatus = "Unfinalized"> {
+    readonly [TypeId]: TypeId;
+    readonly finalizationStatus: FinalizationStatus_;
+    /**
+     * Names of every function registered into this group's layer scope by
+     * `FunctionImpl.make`. Authoritative only when `finalizationStatus` is
+     * `"Finalized"`; the `"Unfinalized"` value is set to `[]` at `make`-time
+     * since the list is only known once `finalize` snapshots the registry.
+     */
+    readonly registeredFunctionNames: ReadonlyArray<string>;
 }
-declare const TypeId = "@confect/server/GroupImpl";
-type TypeId = typeof TypeId;
-type FinalizationStatus = "Unfinalized" | "Finalized";
-interface GroupImpl<FinalizationStatus_ extends FinalizationStatus = "Unfinalized"> {
-  readonly [TypeId]: TypeId;
-  readonly finalizationStatus: FinalizationStatus_;
-  /**
-   * Names of every function registered into this group's layer scope by
-   * `FunctionImpl.make`. Authoritative only when `finalizationStatus` is
-   * `"Finalized"`; the `"Unfinalized"` value is set to `[]` at `make`-time
-   * since the list is only known once `finalize` snapshots the registry.
-   */
-  readonly registeredFunctionNames: ReadonlyArray<string>;
+export interface Any extends GroupImpl<FinalizationStatus> {
 }
-interface Any extends GroupImpl<FinalizationStatus> {}
-declare const isGroupImpl: (u: unknown) => u is Any;
-interface AnyFinalized extends GroupImpl<"Finalized"> {}
-interface AnyUnfinalized extends GroupImpl<"Unfinalized"> {}
-declare const isFinalizedGroupImpl: (u: unknown) => u is AnyFinalized;
-declare const isUnfinalizedGroupImpl: (u: unknown) => u is AnyUnfinalized;
+export declare const isGroupImpl: (u: unknown) => u is Any;
+export interface AnyFinalized extends GroupImpl<"Finalized"> {
+}
+export interface AnyUnfinalized extends GroupImpl<"Unfinalized"> {
+}
+export declare const isFinalizedGroupImpl: (u: unknown) => u is AnyFinalized;
+export declare const isUnfinalizedGroupImpl: (u: unknown) => u is AnyUnfinalized;
 /**
  * Build the runtime tag for a `GroupImpl` service. The finalization status is
  * embedded in the tag string so that `Unfinalized` and `Finalized` are distinct
@@ -40,10 +38,8 @@ declare const isUnfinalizedGroupImpl: (u: unknown) => u is AnyUnfinalized;
  * `validateImpl` each provide a fresh `Registry`), so at most one `GroupImpl`
  * service of each status exists per build.
  */
-declare const GroupImpl: <FinalizationStatus_ extends FinalizationStatus>({
-  finalizationStatus
-}: {
-  finalizationStatus: FinalizationStatus_;
+export declare const GroupImpl: <FinalizationStatus_ extends FinalizationStatus>({ finalizationStatus, }: {
+    finalizationStatus: FinalizationStatus_;
 }) => Context.Tag<GroupImpl<FinalizationStatus_>, GroupImpl<FinalizationStatus_>>;
 /**
  * Begin a group's impl layer. `databaseSchema` and `group` are retained only as
@@ -52,7 +48,7 @@ declare const GroupImpl: <FinalizationStatus_ extends FinalizationStatus>({
  * `_generated/schema` symmetric with `FunctionImpl.make`). Neither is read at
  * runtime.
  */
-declare const make: <DatabaseSchema_ extends AnyWithProps, Group extends GroupSpec.AnyWithProps>(_databaseSchema: DatabaseSchema_, _group: Group) => Layer.Layer<GroupImpl<"Unfinalized">, never, FromGroupSpec$1<Group>>;
+export declare const make: <DatabaseSchema_ extends DatabaseSchema.AnyWithProps, Group extends GroupSpec.AnyWithProps>(_databaseSchema: DatabaseSchema_, _group: Group) => Layer.Layer<GroupImpl<"Unfinalized">, never, FunctionImpl.FromGroupSpec<Group>>;
 /**
  * Mark a `GroupImpl` layer as fully implemented. The parameter type defaults
  * `RIn = never`, so passing a layer that still requires any `FunctionImpl`
@@ -66,8 +62,6 @@ declare const make: <DatabaseSchema_ extends AnyWithProps, Group extends GroupSp
  * impl completeness against a `GroupSpec`'s expected functions without
  * having to inspect the `Registry` themselves.
  */
-declare const finalize: (group: Layer.Layer<GroupImpl<"Unfinalized">>) => Layer.Layer<GroupImpl<"Finalized">>;
-type FromGroupSpec<Group extends GroupSpec.AnyWithProps> = FromGroupSpec$1<Group>;
-//#endregion
-export { Any, AnyFinalized, AnyUnfinalized, FinalizationStatus, FromGroupSpec, GroupImpl, GroupImpl_d_exports, TypeId, finalize, isFinalizedGroupImpl, isGroupImpl, isUnfinalizedGroupImpl, make };
+export declare const finalize: (group: Layer.Layer<GroupImpl<"Unfinalized">>) => Layer.Layer<GroupImpl<"Finalized">>;
+export type FromGroupSpec<Group extends GroupSpec.AnyWithProps> = FunctionImpl.FromGroupSpec<Group>;
 //# sourceMappingURL=GroupImpl.d.ts.map

package/dist/GroupImpl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GroupImpl.d.ts","names":[],"sources":["../src/GroupImpl.ts"],"mappings":";;;;;;;;;;cAca,MAAA;AAAA,KACD,MAAA,UAAgB,MAAA;AAAA,KAEhB,kBAAA;AAAA,UAEK,SAAA,6BACa,kBAAA;EAAA,UAElB,MAAA,GAAS,MAAA;EAAA,SACV,kBAAA,EAAoB,mBAAA;;;;;;;WAOpB,uBAAA,EAAyB,aAAA;AAAA;AAAA,UAGnB,GAAA,SAAY,SAAA,CAAU,kBAAA;AAAA,cAE1B,WAAA,GAAe,CAAA,cAAa,CAAA,IAAK,GAAA;AAAA,UAG7B,YAAA,SAAqB,SAAA;AAAA,UACrB,cAAA,SAAuB,SAAA;AAAA,cAE3B,oBAAA,GAAwB,CAAA,cAAa,CAAA,IAAK,YAAA;AAAA,cAG1C,sBAAA,GAA0B,CAAA,cAAa,CAAA,IAAK,cAAA;;;;;AA3BzD;;;;;AAEA;;;cAwCa,SAAA,+BAAyC,kBAAA;EAAoB;AAAA;EAGxE,kBAAA,EAAoB,mBAAA;AAAA,MACrB,OAAA,CAAA,GAAA,CAAA,SAAA,CAAA,mBAAA,GAAA,SAAA,CAAA,mBAAA;;;;;;;;cAYY,IAAA,2BACa,YAAA,gBACV,SAAA,CAAU,YAAA,EAExB,eAAA,EAAiB,eAAA,EACjB,MAAA,EAAQ,KAAA,KACP,KAAA,CAAM,KAAA,CACP,SAAA,wBAEA,eAAA,CAA2B,KAAA;;;;;;;AAnD7B;;;;;AAEA;;cAqGa,QAAA,GACX,KAAA,EAAO,KAAA,CAAM,KAAA,CAAM,SAAA,qBAClB,KAAA,CAAM,KAAA,CAAM,SAAA;AAAA,KA6BH,aAAA,eAA4B,SAAA,CAAU,YAAA,IAChD,eAAA,CAA2B,KAAA"}
+{"version":3,"file":"GroupImpl.d.ts","sourceRoot":"","sources":["../src/GroupImpl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,SAAS,MAAM,yBAAyB,CAAC;AAI1D,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAE1C,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAKtC,OAAO,KAAK,KAAK,cAAc,MAAM,kBAAkB,CAAC;AACxD,OAAO,KAAK,KAAK,YAAY,MAAM,gBAAgB,CAAC;AAEpD,eAAO,MAAM,MAAM,8BAA8B,CAAC;AAClD,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC;AAEnC,MAAM,MAAM,kBAAkB,GAAG,aAAa,GAAG,WAAW,CAAC;AAE7D,MAAM,WAAW,SAAS,CACxB,mBAAmB,SAAS,kBAAkB,GAAG,aAAa;IAE9D,QAAQ,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,kBAAkB,EAAE,mBAAmB,CAAC;IACjD;;;;;OAKG;IACH,QAAQ,CAAC,uBAAuB,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACzD;AAED,MAAM,WAAW,GAAI,SAAQ,SAAS,CAAC,kBAAkB,CAAC;CAAG;AAE7D,eAAO,MAAM,WAAW,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,GACZ,CAAC;AAEnC,MAAM,WAAW,YAAa,SAAQ,SAAS,CAAC,WAAW,CAAC;CAAG;AAC/D,MAAM,WAAW,cAAe,SAAQ,SAAS,CAAC,aAAa,CAAC;CAAG;AAEnE,eAAO,MAAM,oBAAoB,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,YACC,CAAC;AAEzD,eAAO,MAAM,sBAAsB,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,cACC,CAAC;AAE3D;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,SAAS,GAAI,mBAAmB,SAAS,kBAAkB,EAAE,yBAEvE;IACD,kBAAkB,EAAE,mBAAmB,CAAC;CACzC,gFAGE,CAAC;AAEJ;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,GACf,eAAe,SAAS,cAAc,CAAC,YAAY,EACnD,KAAK,SAAS,SAAS,CAAC,YAAY,EAEpC,iBAAiB,eAAe,EAChC,QAAQ,KAAK,KACZ,KAAK,CAAC,KAAK,CACZ,SAAS,CAAC,aAAa,CAAC,EACxB,KAAK,EACL,YAAY,CAAC,aAAa,CAAC,KAAK,CAAC,CAahC,CAAC;AA0BJ;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,QAAQ,GACnB,OAAO,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC,KAC3C,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,WAAW,CAAC,CA2BlC,CAAC;AAEJ,MAAM,MAAM,aAAa,CAAC,KAAK,SAAS,SAAS,CAAC,YAAY,IAC5D,YAAY,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC"}