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

package/dist/db/sqlite.d.ts

@@ -0,0 +1,50 @@
+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;
+    /**
+     * How long a write waits for another connection's lock, in milliseconds,
+     * before it fails with "database is locked". Defaults to 5000, the value
+     * `better-sqlite3` uses; `bun:sqlite` and `node:sqlite` start at 0, which
+     * fails the moment a second process — the CLI next to a dev server — is
+     * writing. A timeout the database was already given is kept unless this
+     * is set.
+     */
+    busyTimeout?: number;
+}
+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, opened
+ * as `BEGIN IMMEDIATE` (see `sqliteDialect`): SQLite has exactly one writer,
+ * so there is no pool to pin a transaction to, and the write lock is better
+ * taken up front, where the busy timeout below can wait for it.
+ *
+ * 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;IACZ;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAID,MAAM,WAAW,iBAAkB,SAAQ,aAAa;IACtD,sEAAsE;IACtE,IAAI,EAAE,MAAM,CAAC;CACd;AAoCD;;;;;;;;;;;GAWG;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{ce,st}from"../index-4qrep5f0.js";import{n}from"../index-x72d1hzh.js";var r=5000;class s{database;id;constructor(e,t="sqlite"){this.database=e;this.id=t}async all(e,t){return this.database.prepare(e).all(...t)}async run(e,t){let a=this.database.prepare(e).run(...t);return{rowsAffected:Number(a.changes??0)}}async exec(e){this.database.exec(e)}async close(){this.database.close?.()}}function o(e,t={}){if("file"in e&&typeof e.file==="string")return async()=>o(await u(e.file),e);let a=e;return l(a,t.busyTimeout),new ce(new s(a,t.id??"sqlite"),st)}function l(e,t){if(t===void 0){let[a]=e.prepare("PRAGMA busy_timeout").all();if(Number(a?.timeout??0)>0)return}else if(!Number.isFinite(t)||t<0)throw new n("database","busyTimeout must be a number of milliseconds, 0 or more");e.exec(`PRAGMA busy_timeout = ${Math.trunc(t??r)}`)}async function u(e){for(let t of["bun:sqlite","node:sqlite"])try{let a=await import(t),i=a.Database??a.DatabaseSync;if(i)return new i(e)}catch{}throw new n("database","no SQLite is available in this runtime; pass a database instance instead")}export{o 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,EACV,oBAAoB,EACpB,oBAAoB,EAErB,MAAM,iBAAiB,CAAC;AASzB;;;;;;;;;;;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,oBAqCtB,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,EAMrB,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,CAaR;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;AA2GD,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, RichTextImageOptions, RichTextMark, RichTextMediaImage, 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,oBAAoB,EACpB,YAAY,EACZ,kBAAkB,EAClB,YAAY,GACb,MAAM,gBAAgB,CAAC"}

package/dist/editor.js

@@ -0,0 +1 @@
+import{So,To,Co,Oo,Po,_o,$o,Io,jo,Eo,Mo,Do,qo,Lo,Fo,No,Uo,Jo,Wo,zo,Ho,Bo,Vo,he,En}from"./index-g041kfa5.js";import{k,Z,Ot,rn,ao,lo,Te,Q,co,X,uo,Fe,Go,Ne,Xe,ee}from"./index-hbx67b20.js";export{Oo as blockquoteNode,Jo as boldMark,Po as bulletListNode,Eo as codeBlockNode,Bo as codeMark,Z as defineEditorMark,k as defineEditorNode,Te as describeEditorSchema,So as docNode,Fe as escapeHtml,Go as escapeMarkdown,rn as getEditorMark,Ot as getEditorNode,Do as hardBreakNode,Co as headingNode,Mo as horizontalRuleNode,Ne as htmlAttributes,qo as imageNode,Xe as indentContinuation,Wo as italicMark,Vo as linkMark,$o as listItemNode,_o as orderedListNode,To as paragraphNode,lo as registeredEditorMarks,ao as registeredEditorNodes,Q as renderRichText,he as richTextFromMarkdown,En as richTextFromText,co as richTextToHtml,X as richTextToMarkdown,uo as richTextToPlainText,Ho as strikeMark,ee as stringAttr,Uo as tableCellNode,No as tableHeaderNode,Lo as tableNode,Fo as tableRowNode,jo as taskItemNode,Io as taskListNode,zo 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"}

package/dist/engine/documents.d.ts

@@ -0,0 +1,81 @@
+import type { Actor } from "../types/actor";
+import type { ResolvedCollection } from "../types/config";
+import type { ColumnValue, Row } from "../types/query";
+import type { JsonObject, JsonValue } from "../types/json";
+import { type LocaleContext } from "./locales";
+/**
+ * The columns the engine owns on every document.
+ *
+ * They are accepted in an input object and ignored rather than rejected, so
+ * `update({ id, data: doc })` — reading a document, editing one field and
+ * writing the whole thing back — works without the caller having to strip
+ * them first.
+ */
+export declare const systemDocumentFields: readonly ["id", "revision", "createdAt", "updatedAt", "updatedBy", "deletedAt", "purgeAfter", "scheduledAt", "scheduledPatch", "_fallback", "_localeFields"];
+/**
+ * Turns a stored row into the document a caller sees.
+ *
+ * One locale is resolved here, once, so nothing downstream — hook, event,
+ * REST response, template — ever has to know which fields are translated
+ * (section 9).
+ */
+export declare function rowToDocument(row: Row, collection: ResolvedCollection, locale: LocaleContext): JsonObject;
+export interface StoredData {
+    /** The full document body as it will be written to the `data` column. */
+    data: JsonObject;
+    /** Field names the caller actually wrote, in declaration order. */
+    touched: string[];
+}
+/**
+ * Folds a caller's input into the stored body.
+ *
+ * The caller speaks one locale and the storage speaks all of them, so this is
+ * where a flat `{ title: "Hello" }` becomes `{ title: { en: "Hello" } }`
+ * without disturbing the other translations.
+ */
+export declare function toStoredData(collection: ResolvedCollection, input: JsonObject, locale: LocaleContext, previous?: JsonObject): StoredData;
+/**
+ * Validates the fields a write touched, with the field's own zod schema.
+ *
+ * Only the touched ones: a localized field is required per locale, and
+ * demanding every translation before a German draft can be saved would make
+ * partial translations impossible — which section 9 says are the norm. A
+ * create touches everything, so `required` is still enforced where it matters.
+ */
+export declare function validateFields(collection: ResolvedCollection, data: JsonObject, locale: LocaleContext, fields: string[]): void;
+/** Field names whose resolved value differs between two documents. */
+export declare function changedFields(collection: ResolvedCollection, previous: JsonObject, next: JsonObject): string[];
+/**
+ * A system table row as JSON.
+ *
+ * System tables use real columns and therefore snake_case, which is a storage
+ * detail. A `depth` expansion that handed a template `storage_key` would be
+ * leaking it (a `media` relation is resolved through this).
+ */
+export declare function systemRowToJson(row: Row): JsonObject;
+/**
+ * A scheduled change as it is stored.
+ *
+ * The locale travels with the patch because a patch is written in one
+ * language: applying `{ title: "Hallo" }` next Friday has to write the German
+ * title, not the default one (section 9). The actor travels with it because
+ * the change is applied as an ordinary update and therefore has to pass the
+ * same access control a human write would.
+ */
+export interface ScheduledPatch {
+    data: JsonObject;
+    locale: string;
+    actor: Actor | null;
+}
+export declare function scheduledPatch(row: Row): ScheduledPatch | null;
+/**
+ * The stored revision, defaulting to 1.
+ *
+ * A row written before the column existed reads as revision 1 rather than as
+ * `null`: the number means "how many times this has changed", and a document
+ * that has never changed since the column arrived has changed once.
+ */
+export declare function toRevision(value: ColumnValue | undefined): number;
+export declare function toIso(value: ColumnValue | undefined): string | null;
+export declare function asObject(value: ColumnValue | JsonValue | undefined): JsonObject;
+//# sourceMappingURL=documents.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"documents.d.ts","sourceRoot":"","sources":["../../src/engine/documents.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAE1D,OAAO,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC3D,OAAO,EAGL,KAAK,aAAa,EACnB,MAAM,WAAW,CAAC;AAEnB;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,YAC/B,IAAI,EACJ,UAAU,EACV,WAAW,EACX,WAAW,EACX,WAAW,EACX,WAAW,EACX,YAAY,EACZ,aAAa,EACb,gBAAgB,EAChB,WAAW,EACX,eAAe,CACP,CAAC;AAIX;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,GAAG,EACR,UAAU,EAAE,kBAAkB,EAC9B,MAAM,EAAE,aAAa,GACpB,UAAU,CA2DZ;AAED,MAAM,WAAW,UAAU;IACzB,yEAAyE;IACzE,IAAI,EAAE,UAAU,CAAC;IACjB,mEAAmE;IACnE,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,UAAU,EAAE,kBAAkB,EAC9B,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,aAAa,EACrB,QAAQ,CAAC,EAAE,UAAU,GACpB,UAAU,CA+BZ;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,kBAAkB,EAC9B,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,MAAM,EAAE,GACf,IAAI,CA6BN;AAED,sEAAsE;AACtE,wBAAgB,aAAa,CAC3B,UAAU,EAAE,kBAAkB,EAC9B,QAAQ,EAAE,UAAU,EACpB,IAAI,EAAE,UAAU,GACf,MAAM,EAAE,CAIV;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,GAAG,GAAG,UAAU,CAWpD;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,UAAU,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CACrB;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,GAAG,GAAG,cAAc,GAAG,IAAI,CAQ9D;AAsBD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,WAAW,GAAG,SAAS,GAAG,MAAM,CAGjE;AAED,wBAAgB,KAAK,CAAC,KAAK,EAAE,WAAW,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAInE;AAED,wBAAgB,QAAQ,CACtB,KAAK,EAAE,WAAW,GAAG,SAAS,GAAG,SAAS,GACzC,UAAU,CAKZ"}