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

package/dist/kernel/validation.js

@@ -0,0 +1,54 @@
+/** Helpers of generated input validation: the checks themselves are compiled per operation, no schema is read at request time. */
+import { invalid } from "./surface.js";
+/** INPUT_VALIDATION_FAILED at the JSON pointer `path`. */
+export function fail(path, message) { return invalid(message, path); }
+/** JSON equality for `enum`. */
+export function equal(a, b) {
+    if (a === b)
+        return true;
+    if (!a || !b || typeof a !== "object" || typeof b !== "object" || Array.isArray(a) !== Array.isArray(b))
+        return false;
+    const left = a, right = b, keys = Object.keys(left);
+    return keys.length === Object.keys(right).length && keys.every(key => Object.hasOwn(right, key) && equal(left[key], right[key]));
+}
+const pointer = (key) => key.replace(/~/g, "~0").replace(/\//g, "~1");
+const tests = { string: (value) => typeof value === "string", number: Number.isFinite, integer: Number.isSafeInteger, boolean: (value) => typeof value === "boolean", object: (value) => typeof value === "object" && value !== null && !Array.isArray(value) };
+const is = (value, path, type, nullable) => { if (!(tests[type](value) || nullable && value === null))
+    fail(path, "Expected " + type + (nullable ? " or null." : ".")); };
+/** The check of the publishing transitions' input `{id, expectedVersion}` at `path`. */
+export function transition(path, raw) {
+    const keys = ["id", "expectedVersion"];
+    is(raw, path, "object");
+    const object = raw;
+    for (const key of keys)
+        if (!Object.hasOwn(object, key))
+            fail(path + "/" + key, "Required field is missing.");
+    is(object.id, path + "/id", "string");
+    if (object.id === "")
+        fail(path + "/id", "Value violates minLength.");
+    is(object.expectedVersion, path + "/expectedVersion", "integer");
+    if (object.expectedVersion < 1)
+        fail(path + "/expectedVersion", "Value violates minimum.");
+    for (const key of Object.keys(object))
+        if (!keys.includes(key))
+            fail(path + "/" + pointer(key), "Unknown field.");
+    return object;
+}
+function number(raw, path, integer) { const value = Number(raw); if (raw.trim() === "" || !Number.isFinite(value) || integer && !Number.isSafeInteger(value))
+    fail(path, "Expected a valid number."); return value; }
+function boolean(raw, path) { if (raw !== "true" && raw !== "false")
+    fail(path, "Expected true or false."); return raw === "true"; }
+/**
+ * A View's query string: each declared field (typed `boolean`, `integer` or `number` when the input says so) is read
+ * from `params`, then validated; `limit` and `cursor` are the paging options. `operation` is `views/<name>`.
+ */
+export function query(params, validate, operation, fields) {
+    const input = {};
+    for (const [key, type] of fields) {
+        const raw = params.get(key), path = operation + "/input/" + pointer(key);
+        if (raw !== null)
+            Object.defineProperty(input, key, { value: type === "boolean" ? boolean(raw, path) : type ? number(raw, path, type === "integer") : raw, enumerable: true });
+    }
+    const limit = params.get("limit"), cursor = params.get("cursor");
+    return { input: validate(input), ...(limit === null ? {} : { limit: number(limit, operation + "/limit", true) }), ...(cursor ? { cursor } : {}) };
+}

package/dist/kernel/web-gateway.js

@@ -0,0 +1,68 @@
+/** Selected web authorization loads on a request, outside the ordinary web startup graph. */
+import { web } from "./web.js";
+import { gatewayCaller, hostFailure } from "./host-caller.js";
+import { accessRequest } from "./host-access.js";
+import { authorizeTarget } from "./authorization.js";
+import { forwarded, ContractError } from "./contracts.js";
+export function gatewayWeb(options, table) {
+    const run = async (method, request, env, ctx) => {
+        let caller, failure, ran = false;
+        const access = options.gateway ? accessRequest(ctx, options) : undefined;
+        try {
+            const pathname = new URL(request.url).pathname, path = method === "fetch" ? pathname.replace(/\.md$/, "") : pathname;
+            const page = Object.entries(options.pages).sort(([a], [b]) => (a.match(/\{[^{}]+\}/g)?.length ?? 0) - (b.match(/\{[^{}]+\}/g)?.length ?? 0)).find(([template]) => new RegExp("^" + template.split(/(\{[^{}]+\})/).map(part => part.startsWith("{") ? "[^/]+" : part.replace(/[.*+?^$()|[\]\\]/g, "\\$&")).join("") + "$").test(path))?.[1];
+            const index = pathname === "/llms.txt" || pathname === "/sitemap.xml";
+            if (method === "fetch" ? !["GET", "HEAD"].includes(request.method) || !index && (!pathname.endsWith(".md") || !page?.markdown) : !page)
+                return method === "head" ? "" : undefined;
+            const name = page?.view ?? Object.values(options.pages).find(p => p.list)?.list;
+            await access?.select(name ? `view:${name}` : "web");
+            caller = forwarded(ctx, options.gateway) ? gatewayCaller(ctx, options.gateway, options.fields) : typeof options.caller === "function" ? await options.caller(request, env, { readOnly: true }) : options.caller ?? { kind: "anonymous" };
+            const site = web({ ...options, gateway: undefined, authorize: undefined, onAccess: undefined, caller }, table.map(([name, view]) => [name, { ...view, page: async (...args) => {
+                        try {
+                            ran = true;
+                            await access?.select(`view:${name}`, caller);
+                            await access?.check(true);
+                            view.check?.(caller);
+                            if (options.authorize)
+                                await authorizeTarget(options.authorize, { kind: "view", name }, caller);
+                            if (access?.dryRun)
+                                return { rows: [] };
+                            return view.page(...args);
+                        }
+                        catch (error) {
+                            failure = error;
+                            throw error;
+                        }
+                    } }]));
+            // The ordinary renderer validates query/path fields; wrapped pages decide before any SQL.
+            const result = await site[method](request, env, options.gateway ? undefined : ctx);
+            if (failure)
+                throw failure;
+            if (result === undefined)
+                return;
+            if (access && result instanceof Response && result.status >= 400) {
+                const payload = await result.clone().json().catch(() => null);
+                if (payload?.error)
+                    throw new ContractError(payload.error.code, "", payload.error.path, { status: result.status, fields: payload.error.field ? { field: payload.error.field } : undefined });
+            }
+            if (!ran)
+                return result;
+            if (access?.dryRun) {
+                const response = access.response();
+                return method === "fetch" ? response : "";
+            }
+            access?.finish();
+            return result;
+        }
+        catch (error) {
+            access?.finish(error);
+            if (method === "head")
+                throw error;
+            return hostFailure(error, caller, "web");
+        }
+    };
+    return {
+        fetch: (request, env, ctx) => run("fetch", request, env, ctx),
+        head: (request, env, ctx) => run("head", request, env, ctx),
+    };
+}

package/dist/kernel/web-head.js

@@ -0,0 +1,15 @@
+/** HTML head formatting loads only when the application asks for head tags. */
+const escape = (v) => String(v).replace(/[&<>"']/g, c => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[c]));
+export function headTags(canonical, row, markdown, locales) {
+    let tags = '<link rel="canonical" href="' + escape(canonical) + '">';
+    if (markdown)
+        tags += '<link rel="alternate" type="text/markdown" href="' + escape(canonical + ".md") + '">';
+    if (locales?.[0])
+        tags += '<link rel="alternate" hreflang="' + escape(locales[0]) + '" href="' + escape(canonical) + '">';
+    for (const key of Object.keys(row))
+        if (key.endsWith("_lat") && typeof row[key] === "number" && typeof row[key.slice(0, -4) + "_lng"] === "number") {
+            tags += '<meta name="geo.position" content="' + escape(row[key]) + ";" + escape(row[key.slice(0, -4) + "_lng"]) + '">';
+            break;
+        }
+    return tags;
+}

package/dist/kernel/web-index.js

@@ -0,0 +1,40 @@
+/** /llms.txt and /sitemap.xml bodies; loaded only when an index is requested, so page Workers do not pay for it at startup. */
+const escape = (v) => String(v).replace(/[&<>"']/g, c => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[c]));
+const label = (v) => String(v).replace(/[\r\n]/g, " ").replace(/[\\[\]]/g, "\\$&");
+const size = (s) => new TextEncoder().encode(s).length;
+export async function webIndex(sitemap, options, pages, list, validUrl) {
+    const cap = sitemap ? 50000 : 5000, limit = sitemap ? 50 * 1024 * 1024 : 1024 * 1024;
+    const start = sitemap ? '<?xml version="1.0" encoding="UTF-8"?><urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">' : "# " + label(options.title) + "\n\n> " + label(options.description) + "\n\n## Pages\n\n", end = sitemap ? "</urlset>" : "\n";
+    const links = [];
+    let visited = 0, requests = 0, bytes = size(start + end);
+    if (bytes > limit)
+        throw new TypeError("Web index header exceeds its byte limit.");
+    pagesLoop: for (const entry of pages) {
+        if (!entry.page.list)
+            continue;
+        let cursor;
+        do {
+            if (requests >= (sitemap ? 100 : 10))
+                break pagesLoop;
+            requests++;
+            const page = await list(entry.page.list, cursor);
+            for (const row of page.rows) {
+                if (visited++ >= cap)
+                    break pagesLoop;
+                const url = validUrl(entry.path, row, entry.page.view);
+                if (!url)
+                    continue;
+                const line = sitemap ? "<url><loc>" + escape(url) + "</loc></url>" : "- [" + label(row.title ?? url) + "](" + url + "): " + label(row.description ?? "") + "\n";
+                const length = size(line);
+                if (bytes + length > limit)
+                    break pagesLoop;
+                bytes += length;
+                links.push(line);
+            }
+            if (visited >= cap)
+                break pagesLoop;
+            cursor = page.nextCursor;
+        } while (cursor);
+    }
+    return start + links.join("") + end;
+}

package/dist/kernel/web-response.js

@@ -0,0 +1,8 @@
+/** Response hashing is needed only when a Web route actually renders. */
+export async function webResponse(request, body, type, cacheControl) {
+    const hash = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(body));
+    const etag = '"' + Array.from(new Uint8Array(hash), b => b.toString(16).padStart(2, '0')).join('') + '"';
+    const headers = { 'content-type': type + '; charset=utf-8', 'cache-control': cacheControl, etag };
+    const cached = request.headers.get('if-none-match')?.split(',').some(tag => tag.trim() === '*' || tag.trim().replace(/^W\//, '') === etag);
+    return new Response(cached || request.method === 'HEAD' ? null : body, { status: cached ? 304 : 200, headers });
+}

package/dist/kernel/web.d.ts

@@ -0,0 +1,77 @@
+/** Web output for a generated public View table: /llms.txt, /sitemap.xml, Markdown pages and head tags. SQL owns visibility. */
+import { type Caller, type Gateway, type RequestContext } from "./contracts.js";
+import type { UserFields } from "./user-fields.js";
+import { type Conversions } from "./surface.js";
+/** An app's public Views: row type and input keys per View, and the Views a list may name (input that accepts no fields). */
+export interface App {
+    Rows: Record<string, any>;
+    Inputs: Record<string, string>;
+    List: string;
+}
+type At<T, K> = K extends keyof T ? T[K] : never;
+type Params<S extends string> = S extends `${string}{${infer P}}${infer Rest}` ? P | Params<Rest> : never;
+/** A page: the View that reads one row, an optional list View enumerating its URLs, and an optional Markdown text field. */
+export type Page<A extends App> = {
+    [V in keyof A["Rows"] & string]: {
+        view: V;
+        list?: A["List"];
+        markdown?: {
+            [K in keyof A["Rows"][V]]: A["Rows"][V][K] extends string | null ? K : never;
+        }[keyof A["Rows"][V]] & string;
+    };
+}[keyof A["Rows"] & string];
+type ListKeys<A extends App, T> = T extends {
+    list: infer L extends string;
+} ? keyof At<A["Rows"], L> : string;
+/** `{name}` parameters must equal the View input, and be columns of the list and of the View. */
+export type Pages<A extends App, P extends Record<string, Page<A>>> = {
+    [K in keyof P]: K extends string ? [Params<K>] extends [At<A["Inputs"], P[K]["view"]>] ? [At<A["Inputs"], P[K]["view"]>] extends [Params<K>] ? [Params<K>] extends [ListKeys<A, P[K]>] ? [Params<K>] extends [keyof At<A["Rows"], P[K]["view"]>] ? P[K] : never : never : never : never : never;
+};
+export type Options<A extends App, Database, P extends Record<string, Page<A>>, E> = Omit<WebOptions<Database, E>, "pages"> & {
+    pages: P & Pages<A, P>;
+};
+/** One public View: its query-string reader, paged boundary, bind conversions and boolean input keys. */
+export interface View<Database> {
+    readonly check?: (caller: Caller) => void;
+    /** The input rejects an empty query, so a list cannot name this View. */
+    readonly unlisted?: true;
+    readonly query: (params: URLSearchParams) => {
+        input: Record<string, unknown>;
+    };
+    readonly page: (db: Database, caller: Caller, input: never, paging: {
+        limit: number;
+        cursor?: string;
+    }) => Promise<{
+        rows: Record<string, unknown>[];
+        nextCursor?: string;
+    }>;
+    readonly convert?: Conversions;
+    readonly booleans?: readonly string[];
+}
+export interface WebHandler<E> {
+    fetch(request: Request, env?: E, ctx?: RequestContext): Promise<Response | undefined>;
+    head(request: Request, env?: E, ctx?: RequestContext): Promise<string>;
+}
+export type WebOptions<Database, E> = {
+    db: Database;
+    caller?: Caller | ((request: Request, env: E, authority: {
+        readonly readOnly: boolean;
+    }) => Caller | Promise<Caller>);
+    origin: string;
+    title: string;
+    description: string;
+    locales?: readonly string[];
+    pages: Record<string, {
+        view: string;
+        list?: string;
+        markdown?: string;
+    }>;
+    cacheControl?: string;
+    gateway?: Gateway;
+    fields?: UserFields;
+    authorize?: import("./contracts.js").Authorize;
+    onAccess?: import("./contracts.js").GatewayOptions["onAccess"];
+    accessTargets?: import("./contracts.js").GatewayOptions["accessTargets"];
+};
+export declare function web<Database, E>(options: WebOptions<Database, E>, table: readonly (readonly [string, View<Database>])[]): WebHandler<E>;
+export {};

package/dist/kernel/web.js

@@ -0,0 +1,124 @@
+/** Web output for a generated public View table: /llms.txt, /sitemap.xml, Markdown pages and head tags. SQL owns visibility. */
+import { forwarded, wire, ContractError } from "./contracts.js";
+import { convert, decode } from "./surface.js";
+const NO_STORE = { "cache-control": "no-store" };
+const notFound = () => new Response(null, { status: 404, headers: NO_STORE });
+export function web(options, table) {
+    const views = new Map(table);
+    const query = (name, db, caller, params, cursor) => {
+        const view = views.get(name), input = { ...view.query(params).input };
+        convert(input, view.convert);
+        return view.page(db, caller, input, { limit: 500, cursor });
+    };
+    for (const [path, page] of Object.entries(options.pages))
+        if (page.list && views.get(page.list)?.unlisted)
+            throw new TypeError(`Page ${path} lists View '${page.list}', whose input rejects an empty query; a list View must accept no input.`);
+    const origin = new URL(options.origin);
+    if (!/^https?:$/.test(origin.protocol) || origin.username || origin.password || origin.pathname !== "/" || origin.search || origin.hash)
+        throw new TypeError("origin must be an HTTP(S) origin.");
+    const pages = Object.entries(options.pages).map(([path, page]) => {
+        if (!path.startsWith("/") || /[?#]/.test(path))
+            throw new TypeError("Page templates must be absolute paths without queries or fragments.");
+        const keys = [];
+        const pattern = path.split(/(\{[^{}]+\})/).map(part => part.startsWith("{") ? (keys.push(part.slice(1, -1)), "([^/]+)") : part.replace(/[.*+?^$()|[\]\\]/g, "\\$&")).join("");
+        return { path, page, keys, pattern: new RegExp("^" + pattern + "$") };
+    }).sort((a, b) => a.keys.length - b.keys.length);
+    const context = async (request, env, ctx) => ({ db: options.db, caller: forwarded(ctx, options.gateway)
+            ? (await import("./host-caller.js")).gatewayCaller(ctx, options.gateway, options.fields)
+            : typeof options.caller === "function" ? await options.caller(request, env, { readOnly: ["GET", "HEAD"].includes(request.method) }) : options.caller ?? { kind: "anonymous" } });
+    const urlFor = (path, row, view) => origin.origin + path.replace(/\{([^{}]+)\}/g, (_, key) => {
+        let value = row[key];
+        if (views.get(view).booleans?.includes(key) && (value === 0 || value === 1))
+            value = Boolean(value);
+        if (value === null || value === undefined)
+            throw new TypeError("List View must return every page parameter: " + key);
+        const segment = String(value);
+        if (segment === "." || segment === "..")
+            return "";
+        return encodeURIComponent(segment).replace(/[()]/g, c => "%" + c.charCodeAt(0).toString(16).toUpperCase());
+    });
+    const validUrl = (path, row, view) => { if ([...path.matchAll(/\{([^{}]+)\}/g)].some(([, key]) => row[key] === "." || row[key] === ".."))
+        return; return urlFor(path, row, view); };
+    const match = (path) => {
+        for (const entry of pages) {
+            const hit = entry.pattern.exec(path);
+            if (!hit)
+                continue;
+            return { ...entry, params: new URLSearchParams(decode(entry.keys, hit, "Malformed URL parameter.", "web/path")) };
+        }
+    };
+    const read = async (entry, ctx) => (await query(entry.page.view, ctx.db, ctx.caller, entry.params)).rows[0];
+    const response = async (request, body, type, caller) => {
+        const { webResponse } = await import('./web-response.js');
+        return webResponse(request, body, type, caller.kind === "anonymous" ? (options.cacheControl ?? "public, max-age=60") : "private, no-store");
+    };
+    if (options.gateway || options.authorize) {
+        let handle;
+        const load = async () => handle ??= (await import("./web-gateway.js")).gatewayWeb(options, table);
+        return {
+            fetch: async (request, env, ctx) => (await load()).fetch(request, env, ctx),
+            head: async (request, env, ctx) => (await load()).head(request, env, ctx),
+        };
+    }
+    return {
+        async fetch(request, env, execution) {
+            let caller;
+            try {
+                if (request.method !== "GET" && request.method !== "HEAD")
+                    return;
+                const path = new URL(request.url).pathname, index = path === "/llms.txt" || path === "/sitemap.xml";
+                const entry = !index && path.endsWith(".md") ? match(path.slice(0, -3)) : undefined, markdown = entry?.page.markdown;
+                if (!index && !markdown)
+                    return;
+                const ctx = await context(request, env, execution);
+                caller = ctx.caller;
+                if (index) {
+                    const sitemap = path === "/sitemap.xml";
+                    const body = await (await import("./web-index.js")).webIndex(sitemap, options, pages, (list, cursor) => query(list, ctx.db, ctx.caller, new URLSearchParams(), cursor), validUrl);
+                    return response(request, body, sitemap ? "application/xml" : "text/plain", ctx.caller);
+                }
+                const exact = match(path);
+                if (exact)
+                    try {
+                        if (await read(exact, ctx))
+                            return;
+                    }
+                    catch (error) {
+                        if (wire(error).status !== 400)
+                            throw error;
+                    }
+                const row = await read(entry, ctx);
+                if (!row)
+                    return notFound();
+                const body = row[markdown];
+                if (body == null)
+                    return notFound();
+                if (typeof body !== "string")
+                    throw new TypeError("Markdown field must return text.");
+                return response(request, body, "text/markdown", ctx.caller);
+            }
+            catch (error) {
+                return (await import("./host-caller.js")).hostFailure(error, caller, "web");
+            }
+        },
+        async head(request, env, execution) {
+            try {
+                const path = new URL(request.url).pathname, entry = match(path);
+                if (!entry)
+                    return "";
+                const ctx = await context(request, env, execution), row = await read(entry, ctx);
+                if (!row)
+                    return "";
+                const canonical = validUrl(entry.path, row, entry.page.view);
+                if (!canonical)
+                    return "";
+                return (await import("./web-head.js")).headTags(canonical, row, !!entry.page.markdown, options.locales);
+            }
+            catch (error) {
+                if (error instanceof ContractError && error.code === "HOST_CONTRACT")
+                    throw error;
+                return "";
+            }
+        },
+    };
+}

package/dist/kernel/where.js

@@ -0,0 +1,27 @@
+const COMPARE = { gt: ">", gte: ">=", lt: "<", lte: "<=" };
+/**
+ * `column` is already quoted. `bind` registers one parameter and returns its placeholder. `insensitive` folds both sides of
+ * eq/ne/in/notIn with LOWER (text only) and picks the dialect's case-insensitive LIKE. A null eq/ne is IS [NOT] NULL.
+ * `like` takes a finished pattern (`escapeLike` the literal parts).
+ * @internal
+ */
+export function condition(d, column, operator, value, bind, insensitive = false) {
+    const lhs = insensitive ? `LOWER(${column})` : column;
+    const rhs = (v) => insensitive ? `LOWER(${bind(v)})` : bind(v);
+    switch (operator) {
+        case "in":
+        case "notIn": {
+            const list = Array.isArray(value) ? value : [value];
+            if (!list.length)
+                return operator === "in" ? "1 = 0" : "1 = 1";
+            return `${lhs} ${operator === "in" ? "IN" : "NOT IN"} (${list.map(rhs).join(", ")})`;
+        }
+        case "like": return `${column} ${d.like(insensitive)} ${bind(value)}${d.likeEscape}`;
+        case "eq":
+        case "ne":
+            if (value === null)
+                return `${column} IS ${operator === "eq" ? "" : "NOT "}NULL`;
+            return `${lhs} ${operator === "eq" ? "=" : "<>"} ${rhs(value)}`;
+        default: return `${column} ${COMPARE[operator]} ${bind(value)}`;
+    }
+}

package/dist/testing/index.d.ts

@@ -1,37 +1 @@
-/**
- * `@aotter/mantle/testing`: the dialect compliance suite (ADR-0035 decision 8). A dialect author calls
- * `runStorageConformance({ create, compile })` with their dialect's storage adapter on a real engine and asserts `report.ok`;
- * no test framework is imported. Behavior runs through the dialect (convergence, executor, policy, codec); fixtures are
- * seeded and read with plain SQL, typed values through the dialect's codec. A printer-corpus item the compile side refuses as
- * unsupported passes by that refusal; in every other case a refusal fails the case. The cases compile their SQL
- * with the CLI's parser, so they run in Node, not in a Worker.
- */
-import type { DatabaseDriver } from "../core/driver.js";
-import type { MantleStorageAdapter } from "../core/service.js";
-import type { SqlDialect } from "../spec/index.js";
-export interface StorageConformanceFixture {
-    /** The dialect's runtime side over the fresh database: `prepare` converges it and returns the executor. */
-    readonly storage: MantleStorageAdapter;
-    /** The same database, for the fixture's own plain-SQL seeding and reads. */
-    readonly driver: DatabaseDriver;
-    /** Release the database, even after a failure. */
-    readonly cleanup: () => void | Promise<void>;
-}
-export interface StorageConformanceOptions {
-    /** A fresh, empty database on the engine under test, for each case. Never supply a live database. */
-    readonly create: () => Promise<StorageConformanceFixture>;
-    /** The dialect's compile side (`<dialect>/compile`); D1 when omitted. */
-    readonly compile?: SqlDialect;
-}
-export interface StorageConformanceReport {
-    readonly ok: boolean;
-    /** Every check that ran, with its case, in order. */
-    readonly checks: readonly string[];
-    readonly failures: readonly {
-        readonly check: string;
-        readonly message: string;
-    }[];
-}
-/** Runs every case on its own database. A failing case never suppresses cleanup or the cases after it. */
-export declare function runStorageConformance(options: StorageConformanceOptions): Promise<StorageConformanceReport>;
-//# sourceMappingURL=index.d.ts.map
+export { userCaller as authenticatedAs } from "../kernel/user-caller.js";

package/dist/testing/index.js

@@ -1,43 +1 @@
-import { useCompileSide } from "./harness.js";
-import { Report } from "./report.js";
-import * as requisition from "./cases/requisition.js";
-import * as stock from "./cases/stock.js";
-import * as reportView from "./cases/report-view.js";
-import * as beforeHook from "./cases/before-hook.js";
-import * as policy from "./cases/policy.js";
-import * as searchPlaces from "./cases/search-places.js";
-import * as printer from "./cases/printer.js";
-import * as store from "./cases/store.js";
-const CASES = [
-    ["requisition", requisition], ["stock", stock], ["report-view", reportView], ["before-hook", beforeHook],
-    ["policy", policy], ["search-places", searchPlaces], ["printer", printer], ["store", store],
-];
-/** Runs every case on its own database. A failing case never suppresses cleanup or the cases after it. */
-export async function runStorageConformance(options) {
-    const r = new Report();
-    useCompileSide(options.compile);
-    try {
-        for (const [name, c] of CASES) {
-            const fixture = await options.create();
-            try {
-                await c.run(r, fixture);
-            }
-            catch (e) {
-                r.section(`${name} (crashed)`);
-                r.check("case ran to the end", false, e instanceof Error ? (e.stack ?? e.message) : String(e));
-            }
-            finally {
-                await fixture.cleanup();
-            }
-        }
-    }
-    finally {
-        useCompileSide(undefined);
-    }
-    return {
-        ok: r.failed.length === 0,
-        checks: r.checks.map((c) => `${c.case}: ${c.name}`),
-        failures: r.failed.map((c) => ({ check: `${c.case}: ${c.name}`, message: c.detail ?? "" })),
-    };
-}
-//# sourceMappingURL=index.js.map
+export { userCaller as authenticatedAs } from "../kernel/user-caller.js";