@aotter/mantle 0.2.0-alpha.1 → 0.2.0-alpha.11

package/dist/kernel/rest.d.ts

@@ -0,0 +1,58 @@
+/** REST request handling for a generated route table: matching, body and parameter decoding, dispatch and errors. */
+import type { Caller, Target, Authorize, Gateway, RequestContext, GatewayOptions } from "./contracts.js";
+import { type Conversions } from "./surface.js";
+type Paging = {
+    limit?: number;
+    cursor?: string;
+};
+/** Options of a generated `rest(...)`; it adds required `handlers` when the app declares ref Procedures. */
+export interface Options<Env, Database> extends GatewayOptions {
+    authorize?: Authorize;
+    gateway?: Gateway;
+    fields?: import("./user-fields.js").UserFields;
+    db: (env: Env) => Database;
+    caller?: (request: Request, env: Env, authority: {
+        readonly readOnly: boolean;
+    }) => Caller | Promise<Caller>;
+}
+/**
+ * One generated route, matched in order: a public View (`query`, `page`) at `GET /api/views/<name>`, or an http
+ * Trigger whose JSON body merges with its `{name}` path parameters (typed as the input declares them). The
+ * generator prints `pattern` (encoded segments, optional trailing slash) and `keys`, so mounting runs no code.
+ */
+export interface Route<Database, Handlers = never, Env = unknown> {
+    readonly method: string;
+    /** Describe route id; parameterized native routes supply their path template. */
+    readonly id?: string;
+    /** Compiler-proved read-only Procedure; ref handlers never qualify. */
+    readonly readOnly?: boolean;
+    readonly target?: Target;
+    /** Generated requires guard, used before application authorization. */
+    readonly check?: (caller: Caller) => void;
+    /** A selected native surface can preserve the Request and return its own Response. */
+    readonly handle?: (request: Request, env: Env, getDb: () => Database, caller: Caller, params: Record<string, string>, handlers: Handlers, input?: Record<string, unknown>) => Promise<unknown>;
+    /** Selected raw APIs may declare a different body limit; JSON routes default to one million bytes. */
+    readonly bodyLimit?: number;
+    /** The app owns raw stream consumption; only the declared Content-Length is checked. */
+    readonly rawBody?: boolean;
+    readonly pattern: RegExp;
+    readonly keys?: readonly string[];
+    readonly convert?: Conversions;
+    readonly query?: (params: URLSearchParams) => {
+        input: Record<string, unknown>;
+    } & Paging;
+    readonly page?: (db: Database, caller: Caller, input: never, paging: Paging) => Promise<unknown>;
+    readonly params?: Readonly<Record<string, "number" | "boolean">>;
+    readonly validate?: (raw: unknown) => Record<string, unknown>;
+    readonly run?: (db: Database, caller: Caller, input: never, handlers: Handlers) => Promise<unknown>;
+}
+export declare function body(request: Request, limit?: number): Promise<Record<string, unknown>>;
+/** Generated REST routes retain the native View/Procedure dispatch. */
+export declare function rest<Env, Database, Handlers = never>(routes: readonly Route<Database, Handlers, Env>[], options: Options<Env, Database> & {
+    handlers?: Handlers;
+}): (request: Request, env: Env, ctx?: RequestContext) => Promise<Response | undefined>;
+/** A selected surface's raw/JSON handlers; its branches are absent from ordinary REST bundles. */
+export declare function nativeRest<Env, Database, Handlers = never>(routes: readonly Route<Database, Handlers, Env>[], options: Options<Env, Database> & {
+    handlers?: Handlers;
+}): (request: Request, env: Env, ctx?: RequestContext) => Promise<Response | undefined>;
+export {};

package/dist/kernel/rest.js

@@ -0,0 +1,38 @@
+import { ContractError } from "./contract-error.js";
+import { invalid } from "./surface.js";
+const headers = { "cache-control": "private, no-store" };
+const fail = message => invalid(message, "rest");
+export async function body(request, limit = 1_000_000) {
+    if (Number(request.headers.get("content-length")) > limit)
+        fail(`Request body exceeds ${limit} bytes.`);
+    return (await import("./json-body.js")).body(request, limit, fail);
+}
+function router(routes, options, send) {
+    let handle;
+    return async (request, env, ctx) => {
+        handle ??= (await import("./rest-router.js")).router(routes, options, send);
+        return handle(request, env, ctx);
+    };
+}
+export function rest(routes, options) {
+    return router(routes, options, async (route, request, env, caller, params, access) => {
+        const { dispatch } = await import("./rest-dispatch.js");
+        return dispatch(route, request, () => options.db(env), caller, params, options, access);
+    });
+}
+export function nativeRest(routes, options) {
+    return router(routes, options, async (route, request, env, caller, params, access) => {
+        if (Number(request.headers.get("content-length")) > (route.bodyLimit ?? 1_000_000))
+            fail(`Request body exceeds ${route.bodyLimit ?? 1_000_000} bytes.`);
+        const input = route.rawBody || ["GET", "HEAD", "OPTIONS"].includes(request.method) ? undefined : await body(request, route.bodyLimit);
+        if (access?.dryRun)
+            throw new ContractError("DRY_RUN_UNSUPPORTED", "Opaque native route.", route.id, { status: 412 });
+        let initialized = false, db;
+        const getDb = () => { if (!initialized) {
+            db = options.db(env);
+            initialized = true;
+        } return db; };
+        const output = await route.handle(request, env, getDb, caller, params, options.handlers, input);
+        return output instanceof Response ? output : Response.json(output, { headers });
+    });
+}

package/dist/kernel/scalars.d.ts

@@ -0,0 +1,6 @@
+export declare function encodeTimestamptz(v: string | Date): number;
+/** A date is the string a calendar shows; a Date instant has no single calendar day, so it is not accepted. */
+export declare function encodeDate(v: string): number;
+export declare function isoTimestamptz(v: string | Date): string;
+/** The input itself: the pattern admits only the canonical form, and a day that does not exist was refused. */
+export declare const isoDate: (v: string) => string;

package/dist/kernel/scalars.js

@@ -0,0 +1,36 @@
+import { ContractError } from "./contracts.js";
+export function encodeTimestamptz(v) {
+    if (v instanceof Date) {
+        const micros = v.getTime() * 1000;
+        if (!Number.isSafeInteger(micros))
+            throw new ContractError("SQL_TYPE", "Invalid Date is not a timestamp");
+        return micros;
+    }
+    const m = /^(\d{4}-\d\d-\d\d)[T ]((?:[01]\d|2[0-3]):\d\d(?::\d\d)?)(?:\.(\d{1,6}))?(Z|[+-]\d\d(?::?\d\d)?)$/.exec(v.trim());
+    if (!m)
+        throw new ContractError("SQL_TYPE", `'${v}' is not a timestamp with an explicit offset`);
+    const [, day, time, fraction, offset] = m;
+    const zone = offset === "Z" ? "Z" : offset.length === 3 ? `${offset}:00` : offset.includes(":") ? offset : `${offset.slice(0, 3)}:${offset.slice(3)}`;
+    const secs = Date.parse(`${day}T${time.length === 5 ? time + ":00" : time}${zone}`);
+    encodeDate(day);
+    const micros = secs * 1000 + Number((fraction ?? "").padEnd(6, "0"));
+    if (Number.isNaN(secs) || !Number.isSafeInteger(micros))
+        throw new ContractError("SQL_TYPE", `'${v}' is not a valid timestamp`);
+    return micros;
+}
+export function encodeDate(v) {
+    const m = /^(\d{4})-(\d\d)-(\d\d)$/.exec(v);
+    if (!m)
+        throw new ContractError("SQL_TYPE", `'${v}' is not a date`);
+    const [, y, mo, d] = m;
+    const dt = new Date(0);
+    dt.setUTCFullYear(+y, +mo - 1, +d);
+    if (dt.getUTCDate() !== +d || dt.getUTCMonth() !== +mo - 1)
+        throw new ContractError("SQL_TYPE", `'${v}' is not a valid date`);
+    return dt.getTime() / 86_400_000;
+}
+export function isoTimestamptz(v) {
+    const us = encodeTimestamptz(v), ms = Math.floor(us / 1000);
+    return new Date(ms).toISOString().replace("Z", String(us - ms * 1000).padStart(3, "0") + "Z");
+}
+export const isoDate = (v) => (encodeDate(v), v);

package/dist/kernel/search.js

@@ -0,0 +1,4 @@
+export function searchLike(columns, query, operator) {
+    const pattern = `'%' || replace(replace(replace(${query}, '!', '!!'), '%', '!%'), '_', '!_') || '%'`;
+    return columns.map(column => `${column} ${operator} ${pattern} ESCAPE '!'`).join(' OR ');
+}

package/dist/{core/site.d.ts → kernel/site-types.d.ts}

@@ -1,16 +1,45 @@
-/**
- * Site config and media: the runtime's one optional capability over Core's product tables `site_config`, `media_assets` and
- * `pending_media_uploads` (ADR-0032 decision 11). A storage adapter given `site` defaults returns it; a runtime without it boots.
- */
-import type { SiteConfig } from "../spec/domain/index.js";
-/** What the Admin settings page edits. An omitted field is unchanged; an empty string clears it. */
+/** Optional site/media DTOs; asset times keep the 0.2 millisecond wire shape. */
+export interface SiteIcon {
+    readonly src: string;
+    readonly mimeType?: string;
+    readonly sizes?: readonly string[];
+    readonly theme?: "light" | "dark";
+}
+export interface MediaPurposePolicy {
+    readonly name: string;
+    readonly required: readonly string[];
+    readonly maxBytes: Readonly<Record<string, number>>;
+}
+export interface SiteDefaults {
+    readonly brand?: string;
+    readonly title?: string;
+    readonly description?: string;
+    readonly origin?: string;
+    readonly locales?: readonly string[];
+    readonly icons?: readonly SiteIcon[];
+    readonly media?: {
+        readonly purposes?: readonly MediaPurposePolicy[];
+    };
+}
+export interface SiteConfig {
+    readonly brand: string;
+    readonly title: string;
+    readonly description: string;
+    readonly origin: string;
+    readonly locales: readonly string[];
+    readonly canonicalLocale: string | null;
+    readonly icons: readonly SiteIcon[];
+    readonly media: {
+        readonly purposes: readonly MediaPurposePolicy[];
+    };
+}
 export interface SiteSettings {
     readonly brand?: string;
     readonly title?: string;
     readonly description?: string;
 }
 export interface MantleSite {
-    /** Stored values over the defaults: operator fields were seeded once, deployment fields synced at boot. */
+    /** Stored operator values over generated defaults; deployment fields are code constants. */
     read(): Promise<SiteConfig>;
     updateSettings(values: SiteSettings): Promise<SiteConfig>;
     /** The media library over this site's tables, its objects in `storage`. */
@@ -60,7 +89,8 @@ export interface MediaStorage {
     }>;
     /**
      * Checks every uploaded object's type and size (`MEDIA_OBJECT_NOT_FOUND`, `MEDIA_MIME_REJECTED`, `MEDIA_VARIANT_SIZE_EXCEEDED`), all or
-     * nothing, and publishes it under a key no upload URL reaches. On a rejection the caller deletes the upload keys.
+     * nothing, and publishes it under attempt-owned keys no upload URL reaches. Concurrent attempts must never overwrite
+     * or remove each other's copies. On a rejection the caller deletes the upload keys.
      */
     commitUpload(args: {
         readonly uploadGroupId: string;
@@ -114,4 +144,3 @@ export interface MediaLibrary {
         readonly variantsRemoved: number;
     }>;
 }
-//# sourceMappingURL=site.d.ts.map

package/dist/kernel/site-types.js

@@ -0,0 +1 @@
+export {};

package/dist/kernel/site.d.ts

@@ -0,0 +1,39 @@
+/** Optional site capability. Construction does no database work; deployment facts come from generated constants. */
+import { type Caller } from "./contracts.js";
+import { type MediaDatabase } from "./media.js";
+import type { Dialect } from "./dialect/common.js";
+import type { MantleSite, SiteDefaults, SiteConfig, MediaPurposePolicy } from "./site-types.js";
+export type { MantleSite, SiteDefaults, SiteConfig, MediaStorage, MediaAsset, MediaLibrary, MediaPurposePolicy } from "./site-types.js";
+export declare function createSite(db: MediaDatabase, d: Pick<Dialect, "param" | "escapeLike" | "likeEscape" | "like">, caller: Caller, defaults: SiteDefaults, policies: readonly MediaPurposePolicy[]): MantleSite;
+/** 0.2 /admin/api/site projection; the app supplies its selected capabilities. */
+export declare function siteInfo(config: SiteConfig, options: {
+    origin: string;
+    media?: boolean;
+    invitationEmail?: boolean;
+    mcpEndpoints?: {
+        public?: string | null;
+        admin?: string | null;
+    };
+    siteSettings?: boolean;
+}): {
+    publicUrl: string;
+    mcpEndpoints: {
+        public: string | null;
+        admin: string | null;
+    };
+    capabilities: {
+        siteSettings: boolean;
+        media: boolean;
+        invitationEmail: boolean;
+        statistics: boolean;
+    };
+    brand: string;
+    title: string;
+    description: string;
+    locales: readonly string[];
+    canonicalLocale: string | null;
+    icons: readonly import("./site-types.js").SiteIcon[];
+    media: {
+        readonly purposes: readonly MediaPurposePolicy[];
+    };
+};

package/dist/kernel/site.js

@@ -0,0 +1,30 @@
+import { isAdmin, deny } from "./contracts.js";
+import { invalid } from "./surface.js";
+import { mediaLibrary } from "./media.js";
+const icons = [{ src: "/admin/favicon.png", mimeType: "image/png", sizes: ["64x64"] }, { src: "/admin/favicon.svg", mimeType: "image/svg+xml", sizes: ["any"] }];
+export function createSite(db, d, caller, defaults, policies) {
+    const admin = () => deny(caller, isAdmin(caller), "site");
+    const read = async () => {
+        const stored = Object.fromEntries((await db.read("SELECT key, value FROM site_config", [])).map(row => [String(row.key), String(row.value)]));
+        const locales = defaults.locales ?? [];
+        return { brand: stored.brand || defaults.brand || "AotterMantle", title: stored.title ?? defaults.title ?? "CMS", description: stored.description ?? defaults.description ?? "", origin: defaults.origin ?? "", locales, canonicalLocale: locales[0] ?? null, icons: defaults.icons ?? icons, media: { purposes: defaults.media?.purposes ?? [] } };
+    };
+    return { read, async updateSettings(values) {
+            admin();
+            if (!values || typeof values !== "object" || Array.isArray(values))
+                invalid("Site settings must be an object.", "site/settings");
+            const steps = ["brand", "title", "description"].flatMap(key => values[key] === undefined ? [] : [{ sql: `INSERT INTO site_config (key,value) VALUES (${d.param(1)},${d.param(2)}) ON CONFLICT(key) DO UPDATE SET value=excluded.value`, binds: [key, values[key]] }]);
+            for (const key of ["brand", "title", "description"])
+                if (values[key] !== undefined && (typeof values[key] !== "string" || values[key].length > { brand: 80, title: 200, description: 1000 }[key]))
+                    invalid(`Invalid site setting ${key}`, "site/settings");
+            if (steps.length)
+                await db.write(steps);
+            return read();
+        }, media(storage) { admin(); return mediaLibrary(db, d, storage, policies); } };
+}
+export function siteInfo(config, options) {
+    const { origin, ...stored } = config;
+    const publicUrl = URL.canParse(origin) ? origin : options.origin;
+    const at = (path) => path ? new URL(path, publicUrl).href : null;
+    return { ...stored, publicUrl, mcpEndpoints: { public: at(options.mcpEndpoints?.public), admin: at(options.mcpEndpoints?.admin) }, capabilities: { siteSettings: options.siteSettings ?? true, media: !!options.media, invitationEmail: !!options.invitationEmail, statistics: false } };
+}

package/dist/kernel/store.d.ts

@@ -0,0 +1,175 @@
+/**
+ * Generic Store over Core's rowPolicy/writePolicy rules and per-Schema Facts (scope, TTL, publishing, dates).
+ * Generated types own storage column names, values, filters and writable columns; the dialect quotes names and binds values.
+ * Runtime refuses unsafe limits, system/scope writes, undefined values. It applies row rules, not requires.
+ */
+import { type Bound, type Recipe } from "./binds.js";
+import { type Caller, type Row } from "./contracts.js";
+import type { Dialect } from "./dialect/common.js";
+import { decodeCursor, encodeCursor } from "./paging.js";
+export { decodeCursor, encodeCursor };
+/** `eq`: `column = value`; `ttl`: `column IS NULL OR column > value` (Core's `RowTerm`). */
+export type Term = readonly [column: string, op: "eq" | "ttl", value: Recipe] | readonly [column: string, op: "admin", value: Recipe, published: string] | readonly [column: string, op: "parent", value: Recipe, parent: ParentPolicy] | readonly [column: string, op: "in", value: Extract<Recipe, {
+    k: 'user';
+}>];
+export interface ParentPolicy {
+    readonly table: string;
+    readonly terms: readonly Term[];
+    readonly scope?: readonly [parent: string, child: string];
+    readonly admin?: true;
+}
+/** Core's row rules for a Schema with the placeholder columns `SCOPE` and `TTL`; `expand` puts a Schema's own in. */
+export interface Rules {
+    readonly caller: readonly Term[];
+    readonly trusted: readonly Term[];
+    /** An insert's columns the policy fills; `newId` is `newId` below. */
+    readonly fills: readonly (readonly [column: string, value: Recipe | "newId"])[];
+    /** An update's sets beyond the author's columns; `bump` is `column + 1`. */
+    readonly sets: readonly (readonly [column: string, value: Recipe | "bump"])[];
+    readonly lock: Term;
+    /** Core's new entry id as the dialect prints it (an SQL expression). */
+    readonly newId: string;
+}
+/** What a Schema adds to the rules. The table is the collection's name. */
+export interface Fact {
+    readonly u?: readonly Extract<Term, readonly [string, 'in', ...unknown[]]>[];
+    /** The scope column. */
+    readonly s?: string;
+    /** The TTL column and its seconds. */
+    readonly ttl?: readonly [column: string, seconds: number];
+    /** Opt-in publishing lifecycle. */
+    readonly pub?: 1;
+    /** Declared date-time and date columns (`created_at` and `updated_at` are always date-times). */
+    readonly ts?: readonly string[];
+    readonly d?: readonly string[];
+    /** Declared searchable text fields; omitted collections search id only. */
+    readonly search?: readonly string[];
+    /** `x-mantle-ref` columns to a scoped Schema (Core's `refChecks`): a caller's write names a row it sees, in the child's partition. */
+    readonly ref?: readonly {
+        readonly column: string;
+        readonly table: string;
+        readonly field: string;
+        readonly same: readonly (readonly [parent: string, child: string])[];
+        readonly terms: readonly Term[];
+    }[];
+    /** Generated parent policy and inherited read-only columns; no authored schema is interpreted. */
+    readonly parent?: {
+        readonly on: string;
+        readonly scope?: readonly [parent: string, child: string];
+        readonly visible: Term;
+        readonly table: string;
+        readonly caller: readonly Term[];
+        readonly trusted: readonly Term[];
+        readonly fields: readonly string[];
+        readonly ts: readonly string[];
+        readonly d: readonly string[];
+    };
+}
+export declare const SCOPE = "$scope", TTL = "$ttl";
+/** A Schema's rules: the shared ones with its scope and TTL put in, and a term dropped where it has none. The generator proves this equals Core's for every Schema. */
+export declare function expand(r: Rules, f: Fact): {
+    caller: Term[];
+    trusted: Term[];
+    fills: (readonly [column: string, value: Recipe | "newId"])[];
+    sets: (readonly [column: string, value: Recipe | "bump"])[];
+    lock: Term;
+};
+export declare function renderTerm(d: Pick<Dialect, "ident" | 'anyOf'>, t: Term, prefix: string, placeholder: string | ((recipe: Recipe) => string)): string;
+export interface Driver<H> {
+    read(db: H, sql: string, binds: unknown[]): unknown[] | PromiseLike<unknown[]>;
+    procedure(db: H, steps: readonly Bound[], path: string): Promise<Row[][]>;
+    transaction?<R>(db: H, fn: (tx: H) => Promise<R>, options?: TransactionOptions): Promise<R>;
+}
+/** What the generator knows of a collection: its row, its filterable columns, its writable columns, which of those an insert must give, and the NOT NULL indexed columns `orderBy` may name. */
+export interface Table {
+    readonly row: object;
+    readonly fields: object;
+    readonly set: object;
+    readonly required: string;
+    readonly order: string;
+    readonly insert?: object;
+}
+type RowOf<T extends Table> = Readonly<T["row"]>;
+type InsertFields<T extends Table> = T extends {
+    readonly insert: object;
+} ? T['insert'] : T['set'];
+type Insert<T extends Table> = Readonly<Pick<InsertFields<T>, Extract<T["required"], keyof InsertFields<T>>> & Partial<InsertFields<T>>>;
+export type Operators<T> = {
+    readonly eq?: T | null;
+    readonly ne?: T | null;
+    readonly gt?: T;
+    readonly gte?: T;
+    readonly lt?: T;
+    readonly lte?: T;
+    readonly in?: readonly T[];
+    readonly notIn?: readonly T[];
+    readonly like?: string;
+    readonly isNull?: boolean;
+};
+/** Conditions are ANDed; a bare value is `eq` (null is IS NULL). */
+export type Where<F> = {
+    readonly [K in keyof F]?: F[K] | null | Operators<F[K]>;
+};
+export interface Page<R> {
+    readonly rows: R[]; /** Pass back as `cursor` for the next page; null on the last. */
+    readonly cursor: string | null;
+}
+export interface Query<F, O extends string> {
+    readonly where?: Where<F>;
+    readonly search?: string;
+    readonly orderBy?: O;
+    readonly order?: "asc" | "desc";
+    readonly limit?: number;
+    readonly cursor?: string;
+}
+export interface Collection<T extends Table> {
+    findById(id: string): Promise<RowOf<T> | null>;
+    find(query?: Query<T["fields"], T["order"]>): Promise<Page<RowOf<T>>>;
+    first(query?: Omit<Query<T["fields"], T["order"]>, "limit" | "cursor">): Promise<RowOf<T> | null>;
+    count(where?: Where<T["fields"]>): Promise<number>;
+    /** The new row: the writable columns, with scope, author, clock and id filled by the row rules. An anonymous caller cannot insert into a scoped Schema. */
+    insert(values: Insert<T>): Write<RowOf<T>>;
+    /** Writes only the columns given. `lock` is the version the caller read; a different one (or a row the caller cannot see) is CONFLICT, and so is a unique-index clash. Returns the new row. */
+    update(id: string, set: Readonly<Partial<T["set"]>>, options: {
+        readonly lock: number | string;
+    }): Write<RowOf<T>>;
+    /** CONFLICT when the version differs or the caller cannot see the row. */
+    delete(id: string, options: {
+        readonly lock: number | string;
+    }): Write<void>;
+}
+/** Lazy, single-execution write: await it (or `.then`/`.catch`/`.finally`, which run it) or submit it once to its Store's batch. */
+export interface Write<T> extends PromiseLike<T> {
+    catch<R = never>(onrejected?: ((reason: any) => R | PromiseLike<R>) | null): Promise<T | R>;
+    finally(onfinally?: (() => void) | null): Promise<T>;
+}
+export interface TransactionOptions {
+    readonly isolation?: "serializable" | "repeatable read" | "read committed" | "read uncommitted";
+}
+export interface Store<T extends Record<string, Table>> {
+    collection<K extends keyof T & string>(name: K): Collection<T[K]>;
+    batch<const W extends readonly Write<unknown>[]>(writes: W): Promise<{
+        -readonly [K in keyof W]: Awaited<W[K]>;
+    }>;
+}
+type Operations<H> = Record<string, Record<string, (db: H, caller: Caller, input: any, context: any) => Promise<any>>>;
+type BoundOperations<O> = {
+    [K in keyof O]: {
+        [N in keyof O[K]]: O[K][N] extends (db: any, caller: Caller, input: infer I, ...args: any[]) => infer R ? (input: I) => R : never;
+    };
+};
+type Tx<T extends Record<string, Table>, O> = Pick<Store<T>, "collection"> & BoundOperations<O>;
+type Interactive<T extends Record<string, Table>, O> = {
+    transaction<R>(fn: (tx: Tx<T, O>) => Promise<R>, options?: TransactionOptions): Promise<R>;
+};
+/**
+ * A ref handler's `ctx.transaction` on drivers with interactive transactions: it opens one on the handler's Store, or
+ * joins the one that Store already runs in (a handler called through `tx.procedures`), so the handler need not know.
+ */
+export declare function handlerTransaction(store: object, db: unknown): <R>(fn: (ctx: {
+    store: any;
+    db: any;
+}) => Promise<R>) => Promise<R>;
+export declare function createStore<H, T extends Record<string, Table>, D extends Driver<H> = Driver<H>, O extends Operations<H> = {}, C extends object = never>(d: Dialect, drv: D, rules: Rules, facts: {
+    readonly [K in keyof T]: Fact;
+}, operations?: O): (db: H, caller: Caller, ...options: [C] extends [never] ? [] : [options: C]) => Store<T> & BoundOperations<O> & (D extends Required<Pick<Driver<H>, "transaction">> ? Interactive<T, O> : {});