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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Heyo.sh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,45 @@
-# Temporary Holding Version
+# @heyo-sh/heyo-cms
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A framework-agnostic TypeScript CMS: collections, globals, RBAC, editor auth,
+localized content, media, hooks/events, scheduling, AI and signed webhooks.
+Postgres, MongoDB, SQLite and Cloudflare D1. MIT.
+
+## Start a project
+
+Use Node 24+ or Bun:
+
+```bash
+bun create @heyo-sh/heyo-cms
+```
+
+Choose Next.js, Astro or React Router and Vercel or Cloudflare. The generator
+includes `@heyo-sh/heyo-cms-admin`, migrations, a seed, a public page and one
+catch-all route. Follow its printed setup commands.
+
+## CLI
+
+```bash
+heyo-cms generate
+heyo-cms migrate
+heyo-cms status
+heyo-cms create-admin --email you@example.com
+heyo-cms seed
+heyo-cms export --out content.ndjson
+heyo-cms import content.ndjson --on-conflict update
+```
+
+There is no schema `push` mode. Content transfer preserves IDs and localized
+values and runs normal hooks. It is not a backup: media bytes/rows, accounts
+and operational history are excluded; timestamps are new and trash is skipped.
+
+## Telemetry
+
+Only CLI commands report adoption metadata (adapter IDs, counts, feature flags,
+runtime/OS and a configuration-shape hash). A running CMS server never reports.
+`heyo-cms telemetry` prints the payload. Disable with
+`HEYO_TELEMETRY_DISABLED=1`, `DO_NOT_TRACK=1`, or
+`telemetry: { enabled: false }` in config. CI/tests are disabled by default.
+
+[Documentation](https://github.com/heyo-sh/heyo-cms/tree/main/docs) ·
+[API examples and limits](https://github.com/heyo-sh/heyo-cms#readme) ·
+[Benchmarks and methodology](https://github.com/heyo-sh/heyo-cms/tree/main/benchmarks)

package/dist/access/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Role-based access control.
+ *
+ * Pure string work, no database and no engine: the same functions decide an
+ * actor's permissions when a session is created, when an API key is verified
+ * and when an access rule asks a question inside a configuration file.
+ */
+export { expandRoles, grants, intersectPermissions, isValidScope, permissionFor, permits, scopePermissions, wildcard, } from "./permissions";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/access/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EACL,WAAW,EACX,MAAM,EACN,oBAAoB,EACpB,YAAY,EACZ,aAAa,EACb,OAAO,EACP,gBAAgB,EAChB,QAAQ,GACT,MAAM,eAAe,CAAC"}

package/dist/access/permissions.d.ts

@@ -0,0 +1,54 @@
+import type { Actor } from "../types/actor";
+/**
+ * The permission grammar: `collection:action`, with `*` on either side.
+ *
+ * Deliberately tiny. A role is a list of patterns, an actor carries the
+ * flattened result, and every check in the engine is one string match — which
+ * is what lets an access rule be written as `permits(actor, "posts:publish")`
+ * in a configuration file without importing anything that touches a database.
+ *
+ * `*` on its own is the administrator: it matches every collection and every
+ * action, including the ones a plugin adds after this file was written.
+ */
+export declare const wildcard = "*";
+/** `posts:create`. The only place the string is assembled. */
+export declare function permissionFor(collection: string, action: string): string;
+/** Does one pattern grant one concrete `collection:action`? */
+export declare function grants(pattern: string, required: string): boolean;
+/**
+ * Does this actor hold the permission?
+ *
+ * Takes the actor rather than the list so an access rule reads the way the
+ * plan writes it, and so `null` — an anonymous caller — is answered here
+ * instead of at every call site.
+ */
+export declare function permits(actor: Actor | null | undefined, required: string): boolean;
+/**
+ * Flattens roles into the patterns they stand for.
+ *
+ * Unknown roles contribute nothing instead of throwing: a role can be deleted
+ * in the panel while a user still references it, and the safe reading of a
+ * grant that no longer exists is "no grant".
+ */
+export declare function expandRoles(roles: string[], definitions: Record<string, string[]>): string[];
+/**
+ * The narrower of two pattern sets.
+ *
+ * An API key cannot grant more than the user it belongs to, so the key's
+ * scopes and the user's permissions are intersected pattern by pattern:
+ * `["*"]` ∩ `["*:read"]` is `["*:read"]`, and `["posts:*"]` ∩ `["*:read"]` is
+ * `["posts:read"]`. Keeping this exact is what makes a read-only key on an
+ * administrator's account actually read-only.
+ */
+export declare function intersectPermissions(left: string[], right: string[]): string[];
+/**
+ * What an API key scope means in the permission grammar.
+ *
+ * `read`, `write` and `delete` are the coarse scopes the plan names; anything
+ * containing a colon is already a pattern and is taken literally, so a key can
+ * be scoped to `posts:update` without inventing a second vocabulary.
+ */
+export declare function scopePermissions(scopes: string[]): string[];
+/** Is this a legal scope string? Used to reject typos at configuration time. */
+export declare function isValidScope(scope: string): boolean;
+//# sourceMappingURL=permissions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"permissions.d.ts","sourceRoot":"","sources":["../../src/access/permissions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAE5C;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,QAAQ,MAAM,CAAC;AAE5B,8DAA8D;AAC9D,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAExE;AAiBD,+DAA+D;AAC/D,wBAAgB,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAIjE;AAED;;;;;;GAMG;AACH,wBAAgB,OAAO,CACrB,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,SAAS,EAC/B,QAAQ,EAAE,MAAM,GACf,OAAO,CAGT;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,MAAM,EAAE,EACf,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GACpC,MAAM,EAAE,CAQV;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EAAE,EACd,KAAK,EAAE,MAAM,EAAE,GACd,MAAM,EAAE,CAkBV;AAQD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CA6B3D;AAED,gFAAgF;AAChF,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAInD"}

package/dist/adapters/astro.d.ts

@@ -0,0 +1,38 @@
+import type { CmsHandler } from "../types/instance";
+/**
+ * Astro.
+ *
+ * ```ts
+ * // src/pages/api/heyo-cms/[...path].ts
+ * import { cmsHandler } from "@heyo-sh/heyo-cms/astro";
+ * import { cms } from "../../../heyo-cms.config";
+ *
+ * export const prerender = false;
+ * export const { GET, POST, PATCH, PUT, DELETE, HEAD, OPTIONS } = cmsHandler(cms);
+ * ```
+ *
+ * Astro hands an endpoint context rather than a `Request`, so the adapter
+ * reaches for `context.request` — the one difference from the Next.js version,
+ * and the reason the import path names the framework instead of a flag doing
+ * it.
+ */
+export interface HandlerLike {
+    handler: CmsHandler;
+}
+/** The shape of what Astro passes an endpoint. */
+export interface AstroContextLike {
+    request: Request;
+}
+export type AstroRoute = (context: AstroContextLike) => Promise<Response>;
+export interface AstroRouteHandlers {
+    GET: AstroRoute;
+    POST: AstroRoute;
+    PATCH: AstroRoute;
+    PUT: AstroRoute;
+    DELETE: AstroRoute;
+    HEAD: AstroRoute;
+    OPTIONS: AstroRoute;
+    ALL: AstroRoute;
+}
+export declare function cmsHandler(cms: HandlerLike): AstroRouteHandlers;
+//# sourceMappingURL=astro.d.ts.map

package/dist/adapters/astro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"astro.d.ts","sourceRoot":"","sources":["../../src/adapters/astro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,UAAU,CAAC;CACrB;AAED,kDAAkD;AAClD,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,EAAE,gBAAgB,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;AAE1E,MAAM,WAAW,kBAAkB;IACjC,GAAG,EAAE,UAAU,CAAC;IAChB,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,UAAU,CAAC;IAClB,GAAG,EAAE,UAAU,CAAC;IAChB,MAAM,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,UAAU,CAAC;IACjB,OAAO,EAAE,UAAU,CAAC;IACpB,GAAG,EAAE,UAAU,CAAC;CACjB;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,WAAW,GAAG,kBAAkB,CAc/D"}

package/dist/adapters/astro.js

@@ -0,0 +1 @@
+function r(t){let e=({request:o})=>t.handler(o);return{GET:e,POST:e,PATCH:e,PUT:e,DELETE:e,HEAD:e,OPTIONS:e,ALL:e}}export{r as cmsHandler};

package/dist/adapters/next.d.ts

@@ -0,0 +1,31 @@
+import type { CmsHandler } from "../types/instance";
+/**
+ * Next.js App Router.
+ *
+ * ```ts
+ * // app/api/heyo-cms/[...path]/route.ts
+ * import { cmsHandler } from "@heyo-sh/heyo-cms/next";
+ * import { cms } from "@/heyo-cms.config";
+ *
+ * export const { GET, POST, PATCH, PUT, DELETE, HEAD, OPTIONS } = cmsHandler(cms);
+ * ```
+ *
+ * One file, and it never changes again: a route added to the core or to a
+ * plugin is served by the same catch-all (section 10). The adapter is this
+ * small because the handler is already `Request → Response`, which is exactly
+ * what a Next.js route handler is.
+ */
+export interface HandlerLike {
+    handler: CmsHandler;
+}
+export interface NextRouteHandlers {
+    GET: CmsHandler;
+    POST: CmsHandler;
+    PATCH: CmsHandler;
+    PUT: CmsHandler;
+    DELETE: CmsHandler;
+    HEAD: CmsHandler;
+    OPTIONS: CmsHandler;
+}
+export declare function cmsHandler(cms: HandlerLike): NextRouteHandlers;
+//# sourceMappingURL=next.d.ts.map

package/dist/adapters/next.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"next.d.ts","sourceRoot":"","sources":["../../src/adapters/next.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,UAAU,CAAC;CACrB;AAED,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,UAAU,CAAC;IAChB,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,UAAU,CAAC;IAClB,GAAG,EAAE,UAAU,CAAC;IAChB,MAAM,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,UAAU,CAAC;IACjB,OAAO,EAAE,UAAU,CAAC;CACrB;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,WAAW,GAAG,iBAAiB,CAa9D"}

package/dist/adapters/next.js

@@ -0,0 +1 @@
+function a(n){let e=(r)=>n.handler(r);return{GET:e,POST:e,PATCH:e,PUT:e,DELETE:e,HEAD:e,OPTIONS:e}}export{a as cmsHandler};

package/dist/adapters/nuxt.d.ts

@@ -0,0 +1,47 @@
+import type { CmsHandler } from "../types/instance";
+/**
+ * Nuxt (h3).
+ *
+ * ```ts
+ * // server/routes/api/heyo-cms/[...path].ts
+ * import { cmsHandler } from "@heyo-sh/heyo-cms/nuxt";
+ * import { cms } from "~/heyo-cms.config";
+ *
+ * export default defineEventHandler(cmsHandler(cms));
+ * ```
+ *
+ * The one adapter that is more than a wrapper, because h3 is the one runtime
+ * in this list that does not hand over a `Request`. Three shapes are accepted,
+ * duck-typed rather than imported: `h3` is not a dependency of this package
+ * and adding one so that a Nuxt project can mount a CMS would make every
+ * other project pay for it.
+ *
+ * - **h3 v2** events carry `event.web.request` — used directly.
+ * - **h3 v1** events carry `event.node.req` — converted, including a
+ *   streaming body, with `node:stream` imported only on this path.
+ * - A plain `Request`, which is what `toWebHandler()` passes.
+ *
+ * The generator has no Nuxt template in v1 (stage 10); the adapter is here
+ * because the contract is the same one every other framework gets.
+ */
+export interface HandlerLike {
+    handler: CmsHandler;
+}
+interface WebEvent {
+    web: {
+        request: Request;
+    };
+}
+interface NodeEvent {
+    node: {
+        req: {
+            method?: string;
+            url?: string;
+            headers: Record<string, string | string[] | undefined>;
+        };
+    };
+}
+export type NuxtEvent = Request | WebEvent | NodeEvent;
+export declare function cmsHandler(cms: HandlerLike): (event: NuxtEvent) => Promise<Response>;
+export {};
+//# sourceMappingURL=nuxt.d.ts.map

package/dist/adapters/nuxt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nuxt.d.ts","sourceRoot":"","sources":["../../src/adapters/nuxt.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,UAAU,CAAC;CACrB;AAED,UAAU,QAAQ;IAChB,GAAG,EAAE;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;CAC3B;AAED,UAAU,SAAS;IACjB,IAAI,EAAE;QACJ,GAAG,EAAE;YACH,MAAM,CAAC,EAAE,MAAM,CAAC;YAChB,GAAG,CAAC,EAAE,MAAM,CAAC;YACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC,CAAC;SACxD,CAAC;KACH,CAAC;CACH;AAED,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,CAAC;AAEvD,wBAAgB,UAAU,CACxB,GAAG,EAAE,WAAW,GACf,CAAC,KAAK,EAAE,SAAS,KAAK,OAAO,CAAC,QAAQ,CAAC,CAEzC"}

package/dist/adapters/nuxt.js

@@ -0,0 +1 @@
+import{e}from"../index-x72d1hzh.js";function y(t){return async(n)=>t.handler(await p(n))}async function p(t){if(t instanceof Request)return t;if(E(t))return t.web.request;if(b(t))return h(t);throw new e("This does not look like an h3 event or a Request. Pass the event from `defineEventHandler`, or use `toWebHandler`.",{status:500,code:"unsupported_event"})}function E(t){return typeof t==="object"&&t!==null&&"web"in t&&typeof t.web?.request==="object"}function b(t){return typeof t==="object"&&t!==null&&"node"in t&&typeof t.node?.req==="object"}async function h(t){let n=t.node.req,o=new Headers;for(let[f,s]of Object.entries(n.headers)){if(s===void 0)continue;for(let l of Array.isArray(s)?s:[s])o.append(f,l)}let u=o.get("host")??"localhost",d=o.get("x-forwarded-proto")??"http",a=new URL(n.url??"/",`${d}://${u}`),r=n.method??"GET";if(!(r!=="GET"&&r!=="HEAD"))return new Request(a,{method:r,headers:o});let{Readable:i}=await import("node:stream"),c=i.toWeb(n);return new Request(a,{method:r,headers:o,body:c,duplex:"half"})}export{y as cmsHandler};

package/dist/adapters/react-router.d.ts

@@ -0,0 +1,29 @@
+import type { CmsHandler } from "../types/instance";
+/**
+ * React Router (and Remix).
+ *
+ * ```ts
+ * // app/routes/api.heyo-cms.$.ts
+ * import { cmsHandler } from "@heyo-sh/heyo-cms/react-router";
+ * import { cms } from "../../heyo-cms.config";
+ *
+ * export const { loader, action } = cmsHandler(cms);
+ * ```
+ *
+ * Two exports rather than seven: React Router routes reads through `loader`
+ * and everything else through `action`, so the CMS needs both and the method
+ * dispatch happens inside the handler where it already lives.
+ */
+export interface HandlerLike {
+    handler: CmsHandler;
+}
+export interface DataFunctionArgs {
+    request: Request;
+}
+export type DataFunction = (args: DataFunctionArgs) => Promise<Response>;
+export interface ReactRouterRouteHandlers {
+    loader: DataFunction;
+    action: DataFunction;
+}
+export declare function cmsHandler(cms: HandlerLike): ReactRouterRouteHandlers;
+//# sourceMappingURL=react-router.d.ts.map

package/dist/adapters/react-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-router.d.ts","sourceRoot":"","sources":["../../src/adapters/react-router.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,UAAU,CAAC;CACrB;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,MAAM,YAAY,GAAG,CAAC,IAAI,EAAE,gBAAgB,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;AAEzE,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,YAAY,CAAC;IACrB,MAAM,EAAE,YAAY,CAAC;CACtB;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,WAAW,GAAG,wBAAwB,CAGrE"}

package/dist/adapters/react-router.js

@@ -0,0 +1 @@
+function a(t){let e=({request:n})=>t.handler(n);return{loader:e,action:e}}export{a as cmsHandler};

package/dist/adapters/sveltekit.d.ts

@@ -0,0 +1,37 @@
+import type { CmsHandler } from "../types/instance";
+/**
+ * SvelteKit.
+ *
+ * ```ts
+ * // src/routes/api/heyo-cms/[...path]/+server.ts
+ * import { cmsHandler } from "@heyo-sh/heyo-cms/sveltekit";
+ * import { cms } from "$lib/heyo-cms.config";
+ *
+ * export const { GET, POST, PATCH, PUT, DELETE, fallback } = cmsHandler(cms);
+ * ```
+ *
+ * The adapter exists in v1; the generator has no SvelteKit template yet
+ * (stage 10). That distinction is the point of a `Request → Response` core:
+ * supporting a framework is this file, not a port — and nothing here pulls
+ * React into a Svelte project's `node_modules`.
+ *
+ * `fallback` is SvelteKit's catch-all for the methods a `+server.ts` does not
+ * name, which is how `HEAD` and `OPTIONS` reach the router.
+ */
+export interface HandlerLike {
+    handler: CmsHandler;
+}
+export interface RequestEventLike {
+    request: Request;
+}
+export type SvelteKitRoute = (event: RequestEventLike) => Promise<Response>;
+export interface SvelteKitRouteHandlers {
+    GET: SvelteKitRoute;
+    POST: SvelteKitRoute;
+    PATCH: SvelteKitRoute;
+    PUT: SvelteKitRoute;
+    DELETE: SvelteKitRoute;
+    fallback: SvelteKitRoute;
+}
+export declare function cmsHandler(cms: HandlerLike): SvelteKitRouteHandlers;
+//# sourceMappingURL=sveltekit.d.ts.map

package/dist/adapters/sveltekit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sveltekit.d.ts","sourceRoot":"","sources":["../../src/adapters/sveltekit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,UAAU,CAAC;CACrB;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,MAAM,cAAc,GAAG,CAAC,KAAK,EAAE,gBAAgB,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;AAE5E,MAAM,WAAW,sBAAsB;IACrC,GAAG,EAAE,cAAc,CAAC;IACpB,IAAI,EAAE,cAAc,CAAC;IACrB,KAAK,EAAE,cAAc,CAAC;IACtB,GAAG,EAAE,cAAc,CAAC;IACpB,MAAM,EAAE,cAAc,CAAC;IACvB,QAAQ,EAAE,cAAc,CAAC;CAC1B;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,WAAW,GAAG,sBAAsB,CAUnE"}

package/dist/adapters/sveltekit.js

@@ -0,0 +1 @@
+function n(t){let e=({request:l})=>t.handler(l);return{GET:e,POST:e,PATCH:e,PUT:e,DELETE:e,fallback:e}}export{n as cmsHandler};

package/dist/ai/assistant/context.d.ts

@@ -0,0 +1,64 @@
+import type { AiPageContext, AiPageContextKind } from "../../types/ai";
+import type { ResolvedCmsConfig, ResolvedCollection } from "../../types/config";
+/**
+ * The page context, taken from the browser and immediately distrusted.
+ *
+ * Everything in it is a *hint about where the editor is looking*, never a
+ * grant. The slug is re-resolved against the configuration, the locale
+ * against the registry, and the document is re-read through `cms.api` with
+ * the actor from the session. This cannot grant access to protected records;
+ * it can still point the model at a different record the caller *can* reach,
+ * so a page hint is never evidence of the user's intent to write to it.
+ *
+ * Parsed defensively rather than validated strictly: a panel version that
+ * sends a field this one does not know about should lose that field, not the
+ * conversation.
+ */
+export declare function parsePageContext(value: unknown): AiPageContext | undefined;
+export interface ResolvedPageContext {
+    kind: AiPageContextKind;
+    collection: ResolvedCollection | null;
+    documentId: string | null;
+    /** The file the details pane is showing, on the media screen only. */
+    mediaId: string | null;
+    /** The sub-surface in front: a rich-text tab, a settings tab, a status. */
+    tab: string | null;
+    locale: string;
+    dirtyFields: string[];
+    baselineRevision: number | null;
+}
+/**
+ * The context with its names turned into configuration objects.
+ *
+ * A slug that names nothing resolves to `null` rather than throwing: the
+ * editor may be on a screen this server version does not have, and refusing
+ * the whole conversation over it would be a worse answer than "I cannot see
+ * what you are looking at, which record did you mean".
+ *
+ * `fallbackLocale` is the language the caller named outside the context
+ * (`runAssistant({ locale })`). It sits between the context and the project
+ * default, because a screen that has no record — a list, the media library —
+ * still has a language, and defaulting to the project's would make the agent
+ * search the English column for an editor who is working in Polish.
+ */
+export declare function resolvePageContext(config: ResolvedCmsConfig, context: AiPageContext | undefined, fallbackLocale?: string | undefined): ResolvedPageContext;
+/**
+ * A collection by whichever name the model used.
+ *
+ * The schema gives it both `name` and `slug` and models are not reliable about
+ * which one they echo back. Accept either unless the same string names two
+ * different collections. In that case guessing a precedence would turn a
+ * legitimate request into a write to the wrong collection. Make the agent
+ * disambiguate by using an unambiguous name or slug instead.
+ */
+export declare function requireCollection(config: ResolvedCmsConfig, name: string, kind?: "collection" | "global"): ResolvedCollection;
+/**
+ * The locale a tool call should use.
+ *
+ * The model may name one; otherwise the page the editor is on decides, and
+ * only then the project default. Guessing the default when the editor is
+ * clearly editing German would write the English column, which is the kind of
+ * mistake that is invisible until somebody opens the other language.
+ */
+export declare function localeFor(config: ResolvedCmsConfig, page: ResolvedPageContext, requested?: string | undefined): string;
+//# sourceMappingURL=context.d.ts.map

package/dist/ai/assistant/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/ai/assistant/context.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACvE,OAAO,KAAK,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AA2BhF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,aAAa,GAAG,SAAS,CAuC1E;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,iBAAiB,CAAC;IACxB,UAAU,EAAE,kBAAkB,GAAG,IAAI,CAAC;IACtC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,sEAAsE;IACtE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,2EAA2E;IAC3E,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,iBAAiB,EACzB,OAAO,EAAE,aAAa,GAAG,SAAS,EAClC,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,GAClC,mBAAmB,CAkCrB;AAoED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,iBAAiB,EACzB,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,YAAY,GAAG,QAAQ,GAC7B,kBAAkB,CAmBpB;AAMD;;;;;;;GAOG;AACH,wBAAgB,SAAS,CACvB,MAAM,EAAE,iBAAiB,EACzB,IAAI,EAAE,mBAAmB,EACzB,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,GAC7B,MAAM,CAUR"}

package/dist/ai/assistant/limits.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Limits enforced in code, shared with the read-only panel description.
+ * A budget the model can talk itself out of is not a budget.
+ */
+export declare const assistantLimits: {
+    readonly maxTurns: 8;
+    readonly maxToolCalls: 16;
+    readonly timeoutMs: 90000;
+};
+//# sourceMappingURL=limits.d.ts.map

package/dist/ai/assistant/limits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"limits.d.ts","sourceRoot":"","sources":["../../../src/ai/assistant/limits.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,eAAe;aAC1B,QAAQ,EAAE,CAAC;aACX,YAAY,EAAE,EAAE;aAChB,SAAS,EAAE,KAAM;CACT,CAAC"}

package/dist/ai/assistant/plans.d.ts

@@ -0,0 +1,83 @@
+import type { Actor } from "../../types/actor";
+import type { AiPlanSummary } from "../../types/ai";
+import type { DatabaseAdapter } from "../../types/database";
+import type { JsonObject } from "../../types/json";
+/** The ceiling on one plan. A bigger intention is several approvals. */
+export declare const maxPlanOperations = 25;
+/**
+ * One operation inside a plan, exactly as it will be executed.
+ *
+ * Normalised at the moment the plan is written: collection *names* rather than
+ * whatever the model typed, the shaped field values rather than Markdown, the
+ * revision the agent actually read. Approving a plan then means replaying this
+ * row — no second pass through the model, no re-interpretation, no chance that
+ * the thing executed differs from the thing displayed.
+ */
+export interface PlanOperation {
+    action: "create" | "update" | "trash" | "restore" | "purge" | "update-global" | "update-media";
+    collection?: string;
+    id?: string;
+    locale?: string | null;
+    expectedRevision?: number;
+    data?: JsonObject;
+    /** What the panel shows for this line. Server-written, never the model's. */
+    label: string;
+    fields: string[];
+}
+export interface StoredPlan {
+    id: string;
+    runId: string;
+    actorId: string | null;
+    kind: string;
+    summary: string;
+    operations: PlanOperation[];
+    status: "pending" | "approved" | "expired";
+    expiresAt: Date;
+}
+export interface PlanStoreOptions {
+    database: () => Promise<DatabaseAdapter>;
+}
+/**
+ * Where a plan waits for a human.
+ *
+ * In the database rather than in memory, for two reasons that both come up in
+ * ordinary use: the approval arrives on a *different* HTTP request from the
+ * one that proposed it, and a deployment with more than one instance will
+ * routinely route those two requests to different processes.
+ */
+export declare class PlanStore {
+    private readonly options;
+    constructor(options: PlanStoreOptions);
+    create(args: {
+        runId: string;
+        actor: Actor | null;
+        kind: string;
+        summary: string;
+        operations: PlanOperation[];
+        now?: Date;
+    }): Promise<StoredPlan>;
+    /**
+     * The plan this actor is allowed to approve, if it is still approvable.
+     *
+     * The actor check is not decoration. A plan is a stored intention to write,
+     * and an id that anybody signed in could POST would turn one editor's
+     * unapproved proposal into another editor's authority.
+     */
+    claim(args: {
+        planId: string;
+        actor: Actor | null;
+        now?: Date;
+    }): Promise<StoredPlan>;
+    /** Records what executing the plan produced, for an interrupted approval. */
+    complete(planId: string, result: JsonObject): Promise<void>;
+}
+/**
+ * The plan as the panel may see it.
+ *
+ * Field *names*, never field values. An approval dialog has to say "this will
+ * change `title` and `body` on three posts", and a dialog that printed the
+ * proposed body would be a dialog nobody reads — which is the failure mode an
+ * approval step exists to prevent.
+ */
+export declare function planSummary(plan: StoredPlan): AiPlanSummary;
+//# sourceMappingURL=plans.d.ts.map

package/dist/ai/assistant/plans.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plans.d.ts","sourceRoot":"","sources":["../../../src/ai/assistant/plans.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,KAAK,EAAoB,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACtE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAa,MAAM,kBAAkB,CAAC;AAO9D,wEAAwE;AACxE,eAAO,MAAM,iBAAiB,KAAK,CAAC;AAEpC;;;;;;;;GAQG;AACH,MAAM,WAAW,aAAa;IAC5B,MAAM,EACF,QAAQ,GACR,QAAQ,GACR,OAAO,GACP,SAAS,GACT,OAAO,GACP,eAAe,GACf,cAAc,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,6EAA6E;IAC7E,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,aAAa,EAAE,CAAC;IAC5B,MAAM,EAAE,SAAS,GAAG,UAAU,GAAG,SAAS,CAAC;IAC3C,SAAS,EAAE,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,OAAO,CAAC,eAAe,CAAC,CAAC;CAC1C;AAED;;;;;;;GAOG;AACH,qBAAa,SAAS;IACR,OAAO,CAAC,QAAQ,CAAC,OAAO;IAApC,YAA6B,OAAO,EAAE,gBAAgB,EAAI;IAEpD,MAAM,CAAC,IAAI,EAAE;QACjB,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;QACpB,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,aAAa,EAAE,CAAC;QAC5B,GAAG,CAAC,EAAE,IAAI,CAAC;KACZ,GAAG,OAAO,CAAC,UAAU,CAAC,CAuCtB;IAED;;;;;;OAMG;IACG,KAAK,CAAC,IAAI,EAAE;QAChB,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;QACpB,GAAG,CAAC,EAAE,IAAI,CAAC;KACZ,GAAG,OAAO,CAAC,UAAU,CAAC,CAqCtB;IAED,6EAA6E;IACvE,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAOhE;CACF;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,UAAU,GAAG,aAAa,CAa3D"}

package/dist/ai/assistant/prompt.d.ts

@@ -0,0 +1,22 @@
+import type { ResolvedPageContext } from "./context";
+/**
+ * The system prompt.
+ *
+ * Short and normative, and it contains no data. Not the schema, not the
+ * collection list, not the record — those arrive through tools, on demand,
+ * already filtered for this actor. A prompt that carried the project would be
+ * paid for on every turn of every conversation and would be stale the moment
+ * somebody added a field.
+ *
+ * Nothing here is load-bearing for security. Every rule it states is also
+ * enforced in the tool layer, which is the only place enforcement belongs: a
+ * prompt is a request to a system that is explicitly designed to generate
+ * plausible text, and the one thing it must never be is the gate.
+ */
+export declare function assistantSystemPrompt(args: {
+    title: string;
+    instructions?: string | undefined;
+    page: ResolvedPageContext;
+    defaultLocale: string;
+}): string;
+//# sourceMappingURL=prompt.d.ts.map

package/dist/ai/assistant/prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.d.ts","sourceRoot":"","sources":["../../../src/ai/assistant/prompt.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAErD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAC1C,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,IAAI,EAAE,mBAAmB,CAAC;IAC1B,aAAa,EAAE,MAAM,CAAC;CACvB,GAAG,MAAM,CAsCT"}

package/dist/ai/assistant/run.d.ts

@@ -0,0 +1,59 @@
+/**
+ * The panel-wide AI assistant.
+ *
+ * One agent, running inside the CMS process, with a small set of typed tools
+ * that call the ordinary public API. That last part is the whole design: a
+ * mutating tool goes through `cms.api.*` / `cms.globals.*` / `cms.media.*`
+ * with the real actor and `source: "ai"`, so an agent write passes exactly the
+ * same access control, field access, validation, hooks, media accounting,
+ * events and activity log as somebody typing into the form.
+ *
+ * There is no SQL tool, no adapter access, no fetch, no file read and no
+ * credential tool. The question "what could a prompt injection make this do"
+ * has a bounded answer because the surface is bounded.
+ *
+ * Nothing re-exports this directory as a barrel on purpose: `ai/service.ts`
+ * imports `./assistant/run` lazily, so a project without the assistant never
+ * resolves the agent runtime's optional dependencies.
+ */
+import type { Actor } from "../../types/actor";
+import type { AiApprovePlanArgs, AiApprovePlanResult, AiAssistantArgs, AiAssistantEvent } from "../../types/ai";
+import type { AiAuth, ResolvedCmsConfig } from "../../types/config";
+import type { DatabaseAdapter } from "../../types/database";
+import type { CmsInstance } from "../../types/instance";
+import type { JsonObject } from "../../types/json";
+export interface AssistantRunOptions {
+    args: AiAssistantArgs;
+    config: ResolvedCmsConfig;
+    cms: CmsInstance;
+    database: () => Promise<DatabaseAdapter>;
+    authFor: (provider: string) => Promise<AiAuth>;
+    record: (type: "ai.agent.completed" | "ai.agent.failed" | "ai.agent.mutation.applied", data: JsonObject, actor: Actor | null, failure?: unknown) => Promise<void>;
+}
+/**
+ * One run of the assistant, as a stream of events the panel understands.
+ *
+ * An async generator rather than a callback or a `Response`: the HTTP layer
+ * wants a stream, a test wants an array, and `cms.ai.runAssistant()` as a local
+ * API wants to be awaited in a loop. All three are the same object here, and
+ * none of them can see pi's own event vocabulary.
+ */
+export declare function runAssistant(options: AssistantRunOptions): AsyncGenerator<AiAssistantEvent>;
+export interface ApprovePlanOptions {
+    args: AiApprovePlanArgs;
+    config: ResolvedCmsConfig;
+    cms: CmsInstance;
+    database: () => Promise<DatabaseAdapter>;
+    record: (type: "ai.agent.completed" | "ai.agent.failed" | "ai.agent.mutation.applied", data: JsonObject, actor: Actor | null, failure?: unknown) => Promise<void>;
+}
+/**
+ * Executing a plan a human approved.
+ *
+ * The model is not in this function and that is the whole point. The row is
+ * read, the session is checked again, the permissions are checked again by
+ * the engine on every write, and the operations run exactly as they were
+ * stored. An approval that went back through the model would be an approval
+ * of something the editor never saw.
+ */
+export declare function approvePlan(options: ApprovePlanOptions): Promise<AiApprovePlanResult>;
+//# sourceMappingURL=run.d.ts.map

package/dist/ai/assistant/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../../src/ai/assistant/run.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,KAAK,EACV,iBAAiB,EACjB,mBAAmB,EACnB,eAAe,EACf,gBAAgB,EAKjB,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EACV,MAAM,EAEN,iBAAiB,EAClB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,EAAE,UAAU,EAAa,MAAM,kBAAkB,CAAC;AAoB9D,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,eAAe,CAAC;IACtB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,GAAG,EAAE,WAAW,CAAC;IACjB,QAAQ,EAAE,MAAM,OAAO,CAAC,eAAe,CAAC,CAAC;IACzC,OAAO,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IAC/C,MAAM,EAAE,CACN,IAAI,EACF,oBAAoB,GAAG,iBAAiB,GAAG,2BAA2B,EACxE,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,KAAK,GAAG,IAAI,EACnB,OAAO,CAAC,EAAE,OAAO,KACd,OAAO,CAAC,IAAI,CAAC,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,wBAAuB,YAAY,CACjC,OAAO,EAAE,mBAAmB,GAC3B,cAAc,CAAC,gBAAgB,CAAC,CA2OlC;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,iBAAiB,CAAC;IACxB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,GAAG,EAAE,WAAW,CAAC;IACjB,QAAQ,EAAE,MAAM,OAAO,CAAC,eAAe,CAAC,CAAC;IACzC,MAAM,EAAE,CACN,IAAI,EACF,oBAAoB,GAAG,iBAAiB,GAAG,2BAA2B,EACxE,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,KAAK,GAAG,IAAI,EACnB,OAAO,CAAC,EAAE,OAAO,KACd,OAAO,CAAC,IAAI,CAAC,CAAC;CACpB;AAED;;;;;;;;GAQG;AACH,wBAAsB,WAAW,CAC/B,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,mBAAmB,CAAC,CAgD9B"}