@heyo-sh/heyo-cms 0.0.0-stage → 0.1.0

package/dist/db/sql/adapter.d.ts

@@ -0,0 +1,57 @@
+import type { AppliedMigration, DatabaseAdapter, DatabaseCapabilities } from "../../types/database";
+import type { Mutation, MutationResult, Query, Row, Tx } from "../../types/query";
+import type { MigrationArtifact, MigrationStep, SchemaSnapshot } from "../../types/schema";
+import type { SqlDialect } from "./dialect";
+import { type SqlDriver } from "./driver";
+export interface SqlAdapterOptions {
+    /** Overrides, for engines that are SQL but not fully featured (D1). */
+    capabilities?: Partial<DatabaseCapabilities>;
+    schema?: SchemaSnapshot;
+}
+/**
+ * One adapter for every SQL engine.
+ *
+ * Postgres, SQLite and D1 differ in a dialect object and a driver, not in a
+ * repository: a bug fixed for one is fixed for all three, and the contract
+ * suite that proves it runs against each.
+ */
+export declare class SqlDatabaseAdapter implements DatabaseAdapter {
+    private readonly driver;
+    private readonly dialect;
+    readonly id: string;
+    readonly capabilities: DatabaseCapabilities;
+    private readonly catalog;
+    private readonly compiler;
+    private readonly renderer;
+    private schema;
+    private journalReady;
+    private transactionDepth;
+    constructor(driver: SqlDriver, dialect: SqlDialect, options?: SqlAdapterOptions);
+    useSchema(schema: SchemaSnapshot): void;
+    introspect(): Promise<SchemaSnapshot>;
+    plan(from: SchemaSnapshot, to: SchemaSnapshot): MigrationStep[];
+    render(steps: MigrationStep[], id: string): MigrationArtifact;
+    applyMigration(artifact: MigrationArtifact): Promise<void>;
+    listAppliedMigrations(): Promise<AppliedMigration[]>;
+    recordMigration(id: string, sum: string): Promise<void>;
+    /**
+     * Runs a function inside a transaction, or inside nothing at all when the
+     * engine has none.
+     *
+     * The nesting counter keeps a hook that calls back into the engine from
+     * issuing a second `BEGIN`, which Postgres warns about and SQLite refuses.
+     */
+    transaction<T>(fn: (tx: Tx) => Promise<T>): Promise<T>;
+    query(tx: Tx, query: Query): Promise<Row[]>;
+    mutate(tx: Tx, mutation: Mutation): Promise<MutationResult>;
+    close(): Promise<void>;
+    /**
+     * Creates the journal.
+     *
+     * It cannot be part of the generated schema: `migrate` has to know what has
+     * already run before it runs anything, so the table that answers that
+     * question must predate the first migration.
+     */
+    private ensureJournal;
+}
+//# sourceMappingURL=adapter.d.ts.map

package/dist/db/sql/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../src/db/sql/adapter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,gBAAgB,EAChB,eAAe,EACf,oBAAoB,EACrB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EACV,QAAQ,EACR,cAAc,EACd,KAAK,EACL,GAAG,EACH,EAAE,EACH,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EACV,iBAAiB,EACjB,aAAa,EACb,cAAc,EACf,MAAM,oBAAoB,CAAC;AAG5B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,EAAmB,KAAK,SAAS,EAAE,MAAM,UAAU,CAAC;AAY3D,MAAM,WAAW,iBAAiB;IAChC,uEAAuE;IACvE,YAAY,CAAC,EAAE,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAC7C,MAAM,CAAC,EAAE,cAAc,CAAC;CACzB;AAED;;;;;;GAMG;AACH,qBAAa,kBAAmB,YAAW,eAAe;IAYtD,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAZ1B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,YAAY,EAAE,oBAAoB,CAAC;IAE5C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuB;IAC/C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAc;IACvC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAiB;IAC1C,OAAO,CAAC,MAAM,CAA+D;IAC7E,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,gBAAgB,CAAK;IAE7B,YACmB,MAAM,EAAE,SAAS,EACjB,OAAO,EAAE,UAAU,EACpC,OAAO,GAAE,iBAAsB,EAYhC;IAED,SAAS,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,CAGtC;IAED,UAAU,IAAI,OAAO,CAAC,cAAc,CAAC,CAIpC;IAED,IAAI,CAAC,IAAI,EAAE,cAAc,EAAE,EAAE,EAAE,cAAc,GAAG,aAAa,EAAE,CAE9D;IAED,MAAM,CAAC,KAAK,EAAE,aAAa,EAAE,EAAE,EAAE,EAAE,MAAM,GAAG,iBAAiB,CAO5D;IAEK,cAAc,CAAC,QAAQ,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAK/D;IAEK,qBAAqB,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAWzD;IAEK,eAAe,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAM5D;IAED;;;;;;OAMG;IACG,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CA2B3D;IAEK,KAAK,CAAC,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC,CAYhD;IAEK,MAAM,CAAC,EAAE,EAAE,EAAE,EAAE,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,cAAc,CAAC,CAehE;IAEK,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAE3B;IAED;;;;;;OAMG;YACW,aAAa;CAW5B"}

package/dist/db/sql/compile.d.ts

@@ -0,0 +1,50 @@
+import type { Mutation, Query, Row } from "../../types/query";
+import type { ColumnType, SchemaSnapshot } from "../../types/schema";
+import type { SqlDialect } from "./dialect";
+export interface CompiledStatement {
+    text: string;
+    values: unknown[];
+}
+/**
+ * Knows what every column holds.
+ *
+ * Built from the snapshot the engine hands the adapter. Without it a row
+ * would come back with a JSON string where the caller expects an object, and
+ * a timestamp as whatever the driver felt like returning.
+ */
+export declare class SchemaCatalog {
+    private readonly columns;
+    private readonly documentColumns;
+    constructor(schema?: SchemaSnapshot);
+    use(schema: SchemaSnapshot): void;
+    columnType(table: string, column: string): ColumnType | undefined;
+    /** The JSON column a table stores its document body in, if it has one. */
+    documentColumn(table: string): string | undefined;
+    tableColumns(table: string): string[];
+    knows(table: string): boolean;
+}
+export declare class SqlCompiler {
+    private readonly dialect;
+    private readonly catalog;
+    constructor(dialect: SqlDialect, catalog: SchemaCatalog);
+    compileQuery(query: Query): CompiledStatement;
+    compileMutation(mutation: Mutation): CompiledStatement;
+    /** Turns driver output back into the values the engine declared. */
+    decodeRow(table: string, row: Record<string, unknown>): Row;
+    private compileSelect;
+    private compileWhere;
+    /**
+     * A comparison decides the type of its own expression.
+     *
+     * The document body is untyped, so `views > 5` has to extract a number and
+     * `slug > "a"` has to extract text out of the very same column. Postgres
+     * refuses to compare the two, which is a feature: the cast belongs to the
+     * comparison, not to the column.
+     */
+    private comparisonExpression;
+    private compileComparison;
+    private expression;
+    private resolve;
+    private encodeColumn;
+}
+//# sourceMappingURL=compile.d.ts.map

package/dist/db/sql/compile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../../src/db/sql/compile.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAGV,QAAQ,EACR,KAAK,EACL,GAAG,EAEJ,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACrE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE5C,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,OAAO,EAAE,CAAC;CACnB;AAED;;;;;;GAMG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA8C;IACtE,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA6B;IAE7D,YAAY,MAAM,CAAC,EAAE,cAAc,EAElC;IAED,GAAG,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,CAYhC;IAED,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,CAEhE;IAED,0EAA0E;IAC1E,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAEhD;IAED,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAEpC;IAED,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAE5B;CACF;AAeD,qBAAa,WAAW;IAEpB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAF1B,YACmB,OAAO,EAAE,UAAU,EACnB,OAAO,EAAE,aAAa,EACrC;IAEJ,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,iBAAiB,CA+B5C;IAED,eAAe,CAAC,QAAQ,EAAE,QAAQ,GAAG,iBAAiB,CAsDrD;IAED,oEAAoE;IACpE,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,GAAG,CAU1D;IAED,OAAO,CAAC,aAAa;IAarB,OAAO,CAAC,YAAY;IAqBpB;;;;;;;OAOG;IACH,OAAO,CAAC,oBAAoB;IAQ5B,OAAO,CAAC,iBAAiB;IA0DzB,OAAO,CAAC,UAAU;IASlB,OAAO,CAAC,OAAO;IAuBf,OAAO,CAAC,YAAY;CAcrB"}

package/dist/db/sql/ddl.d.ts

@@ -0,0 +1,34 @@
+import type { MigrationStep, SchemaSnapshot } from "../../types/schema";
+import type { SqlDialect } from "./dialect";
+/**
+ * Turns neutral steps into the SQL that lands in the repository.
+ *
+ * The output is a file a reviewer reads in a pull request, so it carries the
+ * step summaries as comments and keeps one statement per line. Nothing here
+ * runs against a database: rendering and applying are separate on purpose, or
+ * "review the migration" would mean "review what already happened".
+ */
+export declare class SqlDdlRenderer {
+    private readonly dialect;
+    private readonly target;
+    constructor(dialect: SqlDialect, target: () => SchemaSnapshot);
+    render(steps: MigrationStep[]): string;
+    private renderStep;
+    private createTable;
+    private columnClause;
+    private addColumn;
+    /**
+     * SQLite cannot alter a column, so the table is rebuilt.
+     *
+     * The twelve-step rebuild from the SQLite documentation, minus the steps
+     * that only matter for legacy schemas: create the new shape, copy the
+     * columns both shapes share, swap the names, recreate the indexes.
+     */
+    private alterColumn;
+    private createIndex;
+    private setDocumentField;
+    private unsetDocumentField;
+    private literal;
+    private q;
+}
+//# sourceMappingURL=ddl.d.ts.map

package/dist/db/sql/ddl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ddl.d.ts","sourceRoot":"","sources":["../../../src/db/sql/ddl.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAGV,aAAa,EACb,cAAc,EAEf,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE5C;;;;;;;GAOG;AACH,qBAAa,cAAc;IAEvB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAFzB,YACmB,OAAO,EAAE,UAAU,EACnB,MAAM,EAAE,MAAM,cAAc,EAC3C;IAEJ,MAAM,CAAC,KAAK,EAAE,aAAa,EAAE,GAAG,MAAM,CAMrC;IAED,OAAO,CAAC,UAAU;IAwClB,OAAO,CAAC,WAAW;IAgBnB,OAAO,CAAC,YAAY;IASpB,OAAO,CAAC,SAAS;IAcjB;;;;;;OAMG;IACH,OAAO,CAAC,WAAW;IAsCnB,OAAO,CAAC,WAAW;IAenB,OAAO,CAAC,gBAAgB;IAmBxB,OAAO,CAAC,kBAAkB;IAc1B,OAAO,CAAC,OAAO;IAUf,OAAO,CAAC,CAAC;CAGV"}

package/dist/db/sql/dialect.d.ts

@@ -0,0 +1,35 @@
+import type { ColumnValue } from "../../types/query";
+import type { ColumnSnapshot, ColumnType } from "../../types/schema";
+/**
+ * Everything two SQL engines disagree about.
+ *
+ * The compiler and the DDL renderer are shared; only this table differs. A
+ * third SQL engine is a new object here, not a new adapter.
+ */
+export interface SqlDialect {
+    readonly id: "postgres" | "sqlite";
+    /** `$1` on Postgres, `?` on SQLite. */
+    placeholder(index: number): string;
+    quote(identifier: string): string;
+    columnType(column: Pick<ColumnSnapshot, "type" | "array">): string;
+    /** Extracts a JSON path as a comparable value. */
+    jsonExtract(column: string, path: string[], type: ColumnType): string;
+    /** Extracts a JSON path as JSON, for array membership tests. */
+    jsonArrayMembership(column: string, path: string[], placeholder: string): string;
+    /** Case-insensitive LIKE, when the engine distinguishes the two. */
+    likeOperator(caseInsensitive: boolean): string;
+    encode(value: ColumnValue | undefined, type: ColumnType): unknown;
+    decode(value: unknown, type: ColumnType): ColumnValue;
+    /** True when `ALTER TABLE ... ALTER COLUMN` exists. */
+    readonly supportsAlterColumn: boolean;
+}
+export declare const postgresDialect: SqlDialect;
+/**
+ * SQLite stores timestamps as epoch milliseconds and JSON as text.
+ *
+ * Milliseconds rather than ISO strings: comparisons and ordering are then
+ * plain integer work, and no row can carry a different time zone from its
+ * neighbour.
+ */
+export declare const sqliteDialect: SqlDialect;
+//# sourceMappingURL=dialect.d.ts.map

package/dist/db/sql/dialect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dialect.d.ts","sourceRoot":"","sources":["../../../src/db/sql/dialect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErE;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,EAAE,EAAE,UAAU,GAAG,QAAQ,CAAC;IACnC,uCAAuC;IACvC,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IACnC,KAAK,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC;IAClC,UAAU,CAAC,MAAM,EAAE,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,MAAM,CAAC;IACnE,kDAAkD;IAClD,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CAAC;IACtE,gEAAgE;IAChE,mBAAmB,CACjB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EAAE,EACd,WAAW,EAAE,MAAM,GAClB,MAAM,CAAC;IACV,oEAAoE;IACpE,YAAY,CAAC,eAAe,EAAE,OAAO,GAAG,MAAM,CAAC;IAC/C,MAAM,CAAC,KAAK,EAAE,WAAW,GAAG,SAAS,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC;IAClE,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,GAAG,WAAW,CAAC;IACtD,uDAAuD;IACvD,QAAQ,CAAC,mBAAmB,EAAE,OAAO,CAAC;CACvC;AAiCD,eAAO,MAAM,eAAe,EAAE,UAgD7B,CAAC;AAyBF;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,EAAE,UAgD3B,CAAC"}

package/dist/db/sql/driver.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The narrow surface every SQL engine has to provide.
+ *
+ * Four methods, no driver bundled: `pg`, Neon, PGlite, `bun:sqlite`,
+ * `node:sqlite` and a D1 binding all fit behind it, and the adapter never
+ * learns which one it is talking to.
+ */
+export interface SqlDriver {
+    readonly id: string;
+    all(sql: string, values: unknown[]): Promise<Record<string, unknown>[]>;
+    run(sql: string, values: unknown[]): Promise<{
+        rowsAffected: number;
+    }>;
+    /** Multi-statement DDL. Migrations are the only caller. */
+    exec(sql: string): Promise<void>;
+    /**
+     * Runs a function against a connection pinned for the transaction.
+     *
+     * Optional: a pooled client would otherwise send `BEGIN` on one connection
+     * and the write on another. Engines without interactive transactions (D1)
+     * leave it out and declare `transactions: false`.
+     */
+    transaction?<T>(run: (driver: SqlDriver) => Promise<T>): Promise<T>;
+    close?(): Promise<void>;
+}
+/**
+ * Splits a migration file into statements.
+ *
+ * Quote-aware rather than a plain `split(";")`: a default value or a backfill
+ * literal can contain a semicolon, and cutting a statement in half there
+ * would corrupt a migration in the one place nobody tests twice.
+ */
+export declare function splitStatements(sql: string): string[];
+//# sourceMappingURL=driver.d.ts.map

package/dist/db/sql/driver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"driver.d.ts","sourceRoot":"","sources":["../../../src/db/sql/driver.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;IACxE,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC;QAAE,YAAY,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACvE,2DAA2D;IAC3D,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACjC;;;;;;OAMG;IACH,WAAW,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IACpE,KAAK,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAqCrD"}

package/dist/db/sql/introspect.d.ts

@@ -0,0 +1,15 @@
+import type { SchemaSnapshot } from "../../types/schema";
+import type { SqlDriver } from "./driver";
+/**
+ * Reads the physical schema back out of a live database.
+ *
+ * Only tables and indexes: a database cannot tell which collection a document
+ * belongs to any more than a filesystem can tell which project a file belongs
+ * to. The logical layer lives in the committed snapshot, and `generate` diffs
+ * against that. This is for drift detection — "the database is not what the
+ * migrations say it should be" — which is a different question from "what
+ * changed in the configuration".
+ */
+export declare function introspectPostgres(driver: SqlDriver): Promise<SchemaSnapshot>;
+export declare function introspectSqlite(driver: SqlDriver): Promise<SchemaSnapshot>;
+//# sourceMappingURL=introspect.d.ts.map

package/dist/db/sql/introspect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"introspect.d.ts","sourceRoot":"","sources":["../../../src/db/sql/introspect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,cAAc,EAEf,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAE1C;;;;;;;;;GASG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,SAAS,GAChB,OAAO,CAAC,cAAc,CAAC,CAsDzB;AAED,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,SAAS,GAChB,OAAO,CAAC,cAAc,CAAC,CAkCzB"}

package/dist/db/sqlite.d.ts

@@ -0,0 +1,39 @@
+import type { DatabaseAdapter, DatabaseAdapterFactory } from "../types/database";
+/**
+ * What `bun:sqlite` and `node:sqlite` both already are.
+ *
+ * Synchronous, prepared-statement based, and identical enough in shape that
+ * one driver covers both runtimes. Neither module is imported here: a Worker
+ * bundle must not pull in a native SQLite it will never run.
+ */
+export interface SqliteDatabase {
+    prepare(sql: string): SqliteStatement;
+    exec(sql: string): void;
+    close?(): void;
+}
+export interface SqliteStatement {
+    all(...values: unknown[]): unknown[];
+    run(...values: unknown[]): {
+        changes?: number | bigint;
+    };
+}
+export interface SqliteOptions {
+    id?: string;
+}
+export interface SqliteFileOptions extends SqliteOptions {
+    /** Path on disk. `:memory:` is accepted and is what the tests use. */
+    file: string;
+}
+/**
+ * Creates the SQLite adapter.
+ *
+ * Transactions use the generic `BEGIN`/`COMMIT` path in the adapter: SQLite
+ * has exactly one writer, so there is no pool to pin a transaction to.
+ *
+ * Passing `{ file }` opens the database on first use through whichever SQLite
+ * the runtime provides — `bun:sqlite` or `node:sqlite` — so a configuration
+ * module stays importable in a runtime that has neither.
+ */
+export declare function sqlite(options: SqliteFileOptions): DatabaseAdapterFactory;
+export declare function sqlite(database: SqliteDatabase, options?: SqliteOptions): DatabaseAdapter;
+//# sourceMappingURL=sqlite.d.ts.map

package/dist/db/sqlite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../../src/db/sqlite.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,eAAe,EACf,sBAAsB,EACvB,MAAM,mBAAmB,CAAC;AAK3B;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC7B,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,CAAC;IACtC,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,KAAK,CAAC,IAAI,IAAI,CAAC;CAChB;AAED,MAAM,WAAW,eAAe;IAC9B,GAAG,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,CAAC;IACrC,GAAG,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG;QAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;CAC1D;AAED,MAAM,WAAW,aAAa;IAC5B,EAAE,CAAC,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,iBAAkB,SAAQ,aAAa;IACtD,sEAAsE;IACtE,IAAI,EAAE,MAAM,CAAC;CACd;AAoCD;;;;;;;;;GASG;AACH,wBAAgB,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,sBAAsB,CAAC;AAC3E,wBAAgB,MAAM,CACpB,QAAQ,EAAE,cAAc,EACxB,OAAO,CAAC,EAAE,aAAa,GACtB,eAAe,CAAC"}

package/dist/db/sqlite.js

@@ -0,0 +1 @@
+import{re,Ye}from"../index-b2ecggck.js";import{n}from"../index-x72d1hzh.js";class s{database;id;constructor(t,e="sqlite"){this.database=t;this.id=e}async all(t,e){return this.database.prepare(t).all(...e)}async run(t,e){let a=this.database.prepare(t).run(...e);return{rowsAffected:Number(a.changes??0)}}async exec(t){this.database.exec(t)}async close(){this.database.close?.()}}function r(t,e={}){if("file"in t&&typeof t.file==="string")return async()=>r(await o(t.file),t);return new re(new s(t,e.id??"sqlite"),Ye)}async function o(t){for(let e of["bun:sqlite","node:sqlite"])try{let a=await import(e),i=a.Database??a.DatabaseSync;if(i)return new i(t)}catch{}throw new n("database","no SQLite is available in this runtime; pass a database instance instead")}export{r as sqlite};

package/dist/defaults.d.ts

@@ -0,0 +1,5 @@
+/** Shared defaults that are safe to import from a browser bundle. */
+export declare const defaultBasePath = "/api/heyo-cms";
+export declare const defaultAdminPath = "/admin";
+export declare const defaultMigrationsDirectory = "./migrations";
+//# sourceMappingURL=defaults.d.ts.map

package/dist/defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../src/defaults.ts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,eAAO,MAAM,eAAe,kBAAkB,CAAC;AAC/C,eAAO,MAAM,gBAAgB,WAAW,CAAC;AACzC,eAAO,MAAM,0BAA0B,iBAAiB,CAAC"}

package/dist/duration.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Parses `30d` into milliseconds.
+ *
+ * Durations are strings in the configuration because `2592000000` in a diff
+ * tells a reviewer nothing. They are parsed once, while the configuration is
+ * being built, so a typo is a start-up error rather than a job that silently
+ * never runs.
+ */
+export declare function parseDuration(value: string, path?: string): number;
+/** Parses `25mb` into bytes, for the same reason `parseDuration` exists. */
+export declare function parseByteSize(value: string, path?: string): number;
+//# sourceMappingURL=duration.d.ts.map

package/dist/duration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duration.d.ts","sourceRoot":"","sources":["../src/duration.ts"],"names":[],"mappings":"AAWA;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,SAAK,GAAG,MAAM,CAS9D;AASD,4EAA4E;AAC5E,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,SAAK,GAAG,MAAM,CAS9D"}

package/dist/editor/builtin.d.ts

@@ -0,0 +1,45 @@
+import type { EditorMarkDefinition, EditorNodeDefinition } from "../types/editor";
+/**
+ * The nodes TipTap's starter kit produces, declared through the public API.
+ *
+ * Every one of them goes through `defineEditorNode()` — no shortcut, no
+ * internal map a built-in gets to use and a plugin does not. That is the same
+ * rule the field registry follows, and for the same reason: an extension
+ * point that the product itself bypasses is an extension point nobody can
+ * trust (stage 9).
+ *
+ * The serialisers below are therefore also the worked examples. A plugin
+ * adding a `callout` writes exactly this much code.
+ */
+export declare const docNode: EditorNodeDefinition;
+export declare const paragraphNode: EditorNodeDefinition;
+export declare const headingNode: EditorNodeDefinition;
+export declare const blockquoteNode: EditorNodeDefinition;
+export declare const bulletListNode: EditorNodeDefinition;
+export declare const orderedListNode: EditorNodeDefinition;
+export declare const listItemNode: EditorNodeDefinition;
+export declare const taskListNode: EditorNodeDefinition;
+export declare const taskItemNode: EditorNodeDefinition;
+export declare const codeBlockNode: EditorNodeDefinition;
+export declare const horizontalRuleNode: EditorNodeDefinition;
+export declare const hardBreakNode: EditorNodeDefinition;
+/**
+ * An image, by media id.
+ *
+ * `mediaId` is the attribute the lifecycle counts (section 6): a bare `src`
+ * is a URL, and a URL is not a reference. The serialiser prefers a resolved
+ * URL when the caller can provide one and falls back to the stored `src`,
+ * because a document exported from a CLI still has to render somewhere.
+ */
+export declare const imageNode: EditorNodeDefinition;
+export declare const tableNode: EditorNodeDefinition;
+export declare const tableRowNode: EditorNodeDefinition;
+export declare const tableHeaderNode: EditorNodeDefinition;
+export declare const tableCellNode: EditorNodeDefinition;
+export declare const boldMark: EditorMarkDefinition;
+export declare const italicMark: EditorMarkDefinition;
+export declare const underlineMark: EditorMarkDefinition;
+export declare const strikeMark: EditorMarkDefinition;
+export declare const codeMark: EditorMarkDefinition;
+export declare const linkMark: EditorMarkDefinition;
+//# sourceMappingURL=builtin.d.ts.map

package/dist/editor/builtin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtin.d.ts","sourceRoot":"","sources":["../../src/editor/builtin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AASlF;;;;;;;;;;;GAWG;AAEH,eAAO,MAAM,OAAO,EAAE,oBAKpB,CAAC;AAEH,eAAO,MAAM,aAAa,EAAE,oBAQ1B,CAAC;AAEH,eAAO,MAAM,WAAW,EAAE,oBAWxB,CAAC;AAEH,eAAO,MAAM,cAAc,EAAE,oBAU3B,CAAC;AAEH,eAAO,MAAM,cAAc,EAAE,oBAO3B,CAAC;AAEH,eAAO,MAAM,eAAe,EAAE,oBAkB5B,CAAC;AAEH,eAAO,MAAM,YAAY,EAAE,oBAKzB,CAAC;AAEH,eAAO,MAAM,YAAY,EAAE,oBAMzB,CAAC;AAEH,eAAO,MAAM,YAAY,EAAE,oBAQzB,CAAC;AAEH,eAAO,MAAM,aAAa,EAAE,oBAyB1B,CAAC;AAEH,eAAO,MAAM,kBAAkB,EAAE,oBAO/B,CAAC;AAEH,eAAO,MAAM,aAAa,EAAE,oBAQ1B,CAAC;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,EAAE,oBA0BtB,CAAC;AAEH,eAAO,MAAM,SAAS,EAAE,oBAsBtB,CAAC;AAEH,eAAO,MAAM,YAAY,EAAE,oBAMzB,CAAC;AAEH,eAAO,MAAM,eAAe,EAAE,oBAU5B,CAAC;AAEH,eAAO,MAAM,aAAa,EAAE,oBAU1B,CAAC;AAMH,eAAO,MAAM,QAAQ,EAAE,oBAIrB,CAAC;AAEH,eAAO,MAAM,UAAU,EAAE,oBAIvB,CAAC;AAEH,eAAO,MAAM,aAAa,EAAE,oBAM1B,CAAC;AAEH,eAAO,MAAM,UAAU,EAAE,oBAIvB,CAAC;AAEH,eAAO,MAAM,QAAQ,EAAE,oBAIrB,CAAC;AAEH,eAAO,MAAM,QAAQ,EAAE,oBAWrB,CAAC"}

package/dist/editor/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The rich-text schema: nodes, marks and the serialisers they are required to
+ * carry.
+ *
+ * Importing this module registers the built-in nodes, which is why the
+ * serialisers in `renderRichText()` work without any configuration. A plugin
+ * that adds a node imports `defineEditorNode` from here and gets exactly the
+ * same treatment.
+ */
+export { blockquoteNode, boldMark, bulletListNode, codeBlockNode, codeMark, docNode, hardBreakNode, headingNode, horizontalRuleNode, imageNode, italicMark, linkMark, listItemNode, orderedListNode, paragraphNode, strikeMark, tableCellNode, tableHeaderNode, tableNode, tableRowNode, taskItemNode, taskListNode, underlineMark, } from "./builtin";
+export { richTextFromMarkdown, richTextFromText } from "./markdown";
+export { defineEditorMark, defineEditorNode, describeEditorSchema, getEditorMark, getEditorNode, registeredEditorMarks, registeredEditorNodes, } from "./registry";
+export { escapeHtml, escapeMarkdown, htmlAttributes, indentContinuation, renderRichText, richTextToHtml, richTextToMarkdown, richTextToPlainText, stringAttr, } from "./serialize";
+//# sourceMappingURL=index.d.ts.map

package/dist/editor/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/editor/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EACL,cAAc,EACd,QAAQ,EACR,cAAc,EACd,aAAa,EACb,QAAQ,EACR,OAAO,EACP,aAAa,EACb,WAAW,EACX,kBAAkB,EAClB,SAAS,EACT,UAAU,EACV,QAAQ,EACR,YAAY,EACZ,eAAe,EACf,aAAa,EACb,UAAU,EACV,aAAa,EACb,eAAe,EACf,SAAS,EACT,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,aAAa,GACd,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACpE,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,oBAAoB,EACpB,aAAa,EACb,aAAa,EACb,qBAAqB,EACrB,qBAAqB,GACtB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,UAAU,EACV,cAAc,EACd,cAAc,EACd,kBAAkB,EAClB,cAAc,EACd,cAAc,EACd,kBAAkB,EAClB,mBAAmB,EACnB,UAAU,GACX,MAAM,aAAa,CAAC"}

package/dist/editor/markdown.d.ts

@@ -0,0 +1,19 @@
+import type { RichTextDocument } from "../types/editor";
+/**
+ * Markdown back into a ProseMirror document.
+ *
+ * The AI runtime needs this and nothing else does yet: a model is shown a
+ * field as Markdown, because that is the format every model writes well, and
+ * what comes back has to become a document the editor can open. Without the
+ * parser the only honest options would be inserting the raw Markdown as
+ * literal text — which is what every CMS that bolts AI onto rich text gets
+ * wrong — or refusing AI on rich-text fields.
+ *
+ * It is deliberately a small parser: the block grammar the serialiser in this
+ * directory emits, plus the inline marks. Anything it does not recognise
+ * stays as text, which is the failure mode that loses nothing.
+ */
+export declare function richTextFromMarkdown(markdown: string): RichTextDocument;
+/** A plain string as one paragraph per blank-line-separated chunk. */
+export declare function richTextFromText(text: string): RichTextDocument;
+//# sourceMappingURL=markdown.d.ts.map

package/dist/editor/markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../src/editor/markdown.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAA8B,MAAM,iBAAiB,CAAC;AAEpF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,gBAAgB,CASvE;AAED,sEAAsE;AACtE,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,CAgB/D"}

package/dist/editor/registry.d.ts

@@ -0,0 +1,30 @@
+import type { EditorMarkDefinition, EditorNodeDefinition, EditorSchemaDescription } from "../types/editor";
+/**
+ * Declares a node of the rich-text schema.
+ *
+ * The serialisers are not optional, and that is the whole point of the
+ * function (stage 9). A node without them renders in the panel and nowhere
+ * else: `GET /posts/1` answers with a shape no consumer knows, and the
+ * promise that the REST API is usable without a frontend quietly stops being
+ * true. Refusing at registration makes that failure a start-up error in the
+ * plugin that caused it, naming the plugin, instead of a rendering bug in
+ * somebody else's site.
+ */
+export declare function defineEditorNode(definition: EditorNodeDefinition): EditorNodeDefinition;
+/** Declares a mark. Same contract, one fewer dimension. */
+export declare function defineEditorMark(definition: EditorMarkDefinition): EditorMarkDefinition;
+export declare function getEditorNode(name: string): EditorNodeDefinition | undefined;
+export declare function getEditorMark(name: string): EditorMarkDefinition | undefined;
+export declare function registeredEditorNodes(): string[];
+export declare function registeredEditorMarks(): string[];
+/**
+ * The schema as data, for the panel and for `cms.inspect()`.
+ *
+ * Serialisers and components are dropped: one is a closure and the other is
+ * a React component, and neither survives JSON. What crosses is exactly what
+ * TipTap needs to build a schema — names, groups, content expressions,
+ * attribute defaults — so a plugin's node renders in a bundle compiled before
+ * the plugin existed.
+ */
+export declare function describeEditorSchema(): EditorSchemaDescription;
+//# sourceMappingURL=registry.d.ts.map

package/dist/editor/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/editor/registry.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,oBAAoB,EACpB,oBAAoB,EACpB,uBAAuB,EACxB,MAAM,iBAAiB,CAAC;AAezB;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,oBAAoB,GAC/B,oBAAoB,CA6BtB;AAED,2DAA2D;AAC3D,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,oBAAoB,GAC/B,oBAAoB,CAmBtB;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,oBAAoB,GAAG,SAAS,CAE5E;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,oBAAoB,GAAG,SAAS,CAE5E;AAED,wBAAgB,qBAAqB,IAAI,MAAM,EAAE,CAEhD;AAED,wBAAgB,qBAAqB,IAAI,MAAM,EAAE,CAEhD;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,IAAI,uBAAuB,CAkB9D"}

package/dist/editor/serialize.d.ts

@@ -0,0 +1,41 @@
+import type { RenderRichTextOptions, RichTextNode } from "../types/editor";
+import type { JsonValue } from "../types/json";
+/**
+ * Turning a stored document into something a consumer can use.
+ *
+ * The walker is here and the formatting is in the node definitions, which is
+ * the split that makes a third-party node a first-class one: a definition
+ * receives its children already serialised and decides how to wrap them, and
+ * never has to know how the rest of the tree is rendered (stage 9).
+ *
+ * An unknown node — one written by an editor that had a plugin this
+ * deployment does not — renders its children rather than disappearing. A
+ * paragraph inside a node nobody recognises is still the author's text, and
+ * dropping it would lose content on a configuration change.
+ */
+export declare function renderRichText(value: unknown, options: RenderRichTextOptions): string;
+export declare function richTextToHtml(value: unknown, options?: Omit<RenderRichTextOptions, "format">): string;
+export declare function richTextToMarkdown(value: unknown, options?: Omit<RenderRichTextOptions, "format">): string;
+/**
+ * Text with no markup at all.
+ *
+ * What a search index, an excerpt and a token budget want: three uses that
+ * would each otherwise strip HTML with a regular expression.
+ */
+export declare function richTextToPlainText(value: unknown, options?: Omit<RenderRichTextOptions, "format">): string;
+export declare function escapeHtml(value: string): string;
+/**
+ * Escaping for Markdown, deliberately minimal.
+ *
+ * Only the characters that would otherwise change the structure of the
+ * document. Escaping more produces output full of backslashes, which is
+ * worse than the rare literal asterisk it protects.
+ */
+export declare function escapeMarkdown(value: string): string;
+/** `<a href="x" rel="y">`, with empty attributes dropped. */
+export declare function htmlAttributes(attributes: Record<string, JsonValue | undefined>): string;
+/** Indents every line but the first: Markdown's rule for nested blocks. */
+export declare function indentContinuation(value: string, spaces: number): string;
+export declare function attr(node: RichTextNode, name: string): JsonValue | undefined;
+export declare function stringAttr(node: RichTextNode, name: string): string | undefined;
+//# sourceMappingURL=serialize.d.ts.map

package/dist/editor/serialize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../../src/editor/serialize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,qBAAqB,EAIrB,YAAY,EACb,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAG/C;;;;;;;;;;;;GAYG;AAEH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,qBAAqB,GAC7B,MAAM,CASR;AAED,wBAAgB,cAAc,CAC5B,KAAK,EAAE,OAAO,EACd,OAAO,GAAE,IAAI,CAAC,qBAAqB,EAAE,QAAQ,CAAM,GAClD,MAAM,CAER;AAED,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,OAAO,EACd,OAAO,GAAE,IAAI,CAAC,qBAAqB,EAAE,QAAQ,CAAM,GAClD,MAAM,CAER;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,OAAO,EACd,OAAO,GAAE,IAAI,CAAC,qBAAqB,EAAE,QAAQ,CAAM,GAClD,MAAM,CAER;AAqGD,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAMhD;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED,6DAA6D;AAC7D,wBAAgB,cAAc,CAC5B,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,GAAG,SAAS,CAAC,GAChD,MAAM,CAWR;AAED,2EAA2E;AAC3E,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAGxE;AAED,wBAAgB,IAAI,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAE5E;AAED,wBAAgB,UAAU,CACxB,IAAI,EAAE,YAAY,EAClB,IAAI,EAAE,MAAM,GACX,MAAM,GAAG,SAAS,CAGpB"}

package/dist/editor.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `@heyo-sh/heyo-cms/editor`.
+ *
+ * The rich-text schema and its serialisers. Imported by the panel to build
+ * the TipTap schema, and by anything that has to turn a stored document into
+ * HTML, Markdown or plain text without a browser.
+ */
+export * from "./editor/index";
+export type { EditorMarkDefinition, EditorNodeDefinition, EditorSchemaDescription, MarkSerializer, MarkSerializerContext, NodeSerializer, NodeSerializerContext, RenderRichTextOptions, RichTextDocument, RichTextFormat, RichTextMark, RichTextNode, } from "./types/editor";
+//# sourceMappingURL=editor.d.ts.map

package/dist/editor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editor.d.ts","sourceRoot":"","sources":["../src/editor.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,cAAc,gBAAgB,CAAC;AAC/B,YAAY,EACV,oBAAoB,EACpB,oBAAoB,EACpB,uBAAuB,EACvB,cAAc,EACd,qBAAqB,EACrB,cAAc,EACd,qBAAqB,EACrB,qBAAqB,EACrB,gBAAgB,EAChB,cAAc,EACd,YAAY,EACZ,YAAY,GACb,MAAM,gBAAgB,CAAC"}

package/dist/editor.js

@@ -0,0 +1 @@
+import{x,Y,Ne,wt,Tn,Sn,de,ue,On,J,_n,Ue,oo,We,vt,Z,yo,bo,wo,vo,Ao,xo,ko,Ro,Co,To,So,Oo,_o,Po,$o,jo,Io,Eo,Do,Mo,qo,Lo,Fo,pe,Pn}from"./index-9zqnf6gx.js";export{vo as blockquoteNode,Eo as boldMark,Ao as bulletListNode,To as codeBlockNode,Lo as codeMark,Y as defineEditorMark,x as defineEditorNode,de as describeEditorSchema,yo as docNode,Ue as escapeHtml,oo as escapeMarkdown,wt as getEditorMark,Ne as getEditorNode,Oo as hardBreakNode,wo as headingNode,So as horizontalRuleNode,We as htmlAttributes,_o as imageNode,vt as indentContinuation,Do as italicMark,Fo as linkMark,ko as listItemNode,xo as orderedListNode,bo as paragraphNode,Sn as registeredEditorMarks,Tn as registeredEditorNodes,ue as renderRichText,pe as richTextFromMarkdown,Pn as richTextFromText,On as richTextToHtml,J as richTextToMarkdown,_n as richTextToPlainText,qo as strikeMark,Z as stringAttr,Io as tableCellNode,jo as tableHeaderNode,Po as tableNode,$o as tableRowNode,Co as taskItemNode,Ro as taskListNode,Mo as underlineMark};

package/dist/engine/access.d.ts

@@ -0,0 +1,33 @@
+import type { Actor } from "../types/actor";
+import type { AccessOperation, RbacConfig, ResolvedCollection } from "../types/config";
+import type { JsonObject } from "../types/json";
+import type { Where } from "../types/query";
+export interface AccessRequest {
+    actor: Actor | null;
+    operation: AccessOperation;
+    locale: string | null;
+    record?: JsonObject;
+    /**
+     * Present when the configuration declares roles.
+     *
+     * It changes the default for a collection with no rule from "open" to
+     * "needs `collection:action`" — the only safe reading once roles exist, and
+     * the reason declaring `rbac` is a decision rather than a formality.
+     */
+    rbac?: RbacConfig | undefined;
+}
+/**
+ * Evaluates a collection's access rule for one operation.
+ *
+ * `false` throws here; a `Where` is returned so the caller can add it to the
+ * query with `and(requestWhere, accessWhere)`. Filtering after fetching would
+ * leak through counts, pagination and `hasNextPage` — the rule has to reach
+ * the database, not the serialiser (stage 4).
+ *
+ * An explicit rule is the final word: RBAC is not consulted for an operation
+ * the collection decided for itself, because a rule that said `true` and was
+ * then overruled by a permission the developer forgot to grant would be
+ * indistinguishable from a bug.
+ */
+export declare function accessFilter(collection: ResolvedCollection, request: AccessRequest): Promise<Where | undefined>;
+//# sourceMappingURL=access.d.ts.map

package/dist/engine/access.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"access.d.ts","sourceRoot":"","sources":["../../src/engine/access.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,EACV,eAAe,EAEf,UAAU,EACV,kBAAkB,EACnB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAoB5C,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,SAAS,EAAE,eAAe,CAAC;IAC3B,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC;CAC/B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,YAAY,CAChC,UAAU,EAAE,kBAAkB,EAC9B,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,KAAK,GAAG,SAAS,CAAC,CAiB5B"}

package/dist/engine/activity.d.ts

@@ -0,0 +1,16 @@
+import type { CmsActivity } from "../types/activity";
+import type { DatabaseAdapter } from "../types/database";
+export interface ActivityReaderOptions {
+    database: () => Promise<DatabaseAdapter>;
+}
+/**
+ * `cms.activity`: reading the trail the engine writes.
+ *
+ * Paged by the row id, descending. The ids are ordered — that is why they are
+ * generated the way they are — so the cursor is the last id and nothing else:
+ * paging by `created_at` would repeat or skip rows every time two writes to
+ * the same document land in the same millisecond, which is the normal case
+ * for a form that saves five fields.
+ */
+export declare function createActivity(options: ActivityReaderOptions): CmsActivity;
+//# sourceMappingURL=activity.d.ts.map

package/dist/engine/activity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity.d.ts","sourceRoot":"","sources":["../../src/engine/activity.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAIV,WAAW,EACZ,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AASzD,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,MAAM,OAAO,CAAC,eAAe,CAAC,CAAC;CAC1C;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,WAAW,CAoC1E"}

package/dist/engine/cursor.d.ts

@@ -0,0 +1,19 @@
+import type { OrderBy, Row, Where } from "../types/query";
+/**
+ * Keyset pagination over the sort the caller asked for.
+ *
+ * `offset` re-reads and re-skips every preceding row, which is what makes
+ * page 400 of an archive slow and what makes a page shift when somebody
+ * publishes while a reader is paging. A cursor is a `WHERE`, so it costs the
+ * same on page 400 as on page 1 and cannot skip or repeat a row.
+ */
+export declare function encodeCursor(row: Row, orderBy: OrderBy[]): string;
+/**
+ * Turns a cursor back into a filter.
+ *
+ * For `a asc, b desc` the predicate is `a > va OR (a = va AND b < vb)`: one
+ * disjunct per sort key, each pinning the keys before it. The last key is
+ * always `id`, so the comparison is total and no two rows can tie.
+ */
+export declare function cursorWhere(cursor: string, orderBy: OrderBy[]): Where;
+//# sourceMappingURL=cursor.d.ts.map

package/dist/engine/cursor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cursor.d.ts","sourceRoot":"","sources":["../../src/engine/cursor.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAe,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAevE;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,MAAM,CAUjE;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,KAAK,CA0BrE"}