@plitzi/sdk-shared 0.38.14 → 0.38.15

package/CHANGELOG.md

@@ -1,5 +1,107 @@
 # @plitzi/sdk-shared
 
+## 0.38.15
+
+### Patch Changes
+
+- 6cdd5cf: ## Security
+
+  - **A write another site caused is refused, cookie or none** (`@plitzi/sdk-server`, `@plitzi/sdk-shared`): the page
+    server guarded nothing it answers past `/auth` — a server action (`/_action`), a realtime publish, a space's `/fn/`
+    route, its runtime's endpoints, the deployment's own `data` stages, the adapter-only `loginPath`, `logoutPath` and
+    `exchangePath`. A plain `text/plain` POST from any page open in the same browser ran them, with the visitor's session
+    cookie when there was one (`SameSite=None` off this machine) and, in a project nobody signs in to, as whoever holds
+    the server's own credentials. Every unsafe request a browser says another site caused (`Sec-Fetch-Site: cross-site`,
+    or a foreign `Origin`) is now refused `403 reason: 'foreign'`, saying how to allow it: `crossSiteWrites.origins`
+    (with `auth`, `identity.platformOrigins` too) and `crossSiteWrites.paths` for a form other sites post to by design.
+    `Authorization`, and callers that are not browsers — webhooks, scripts — pass as before. One rule for this and the
+    sign-in check (`crossSiteRequest`, `csrf.ts`). A self-hosted runtime's endpoints now sit where the platform forwards a
+    space's — after the auth chain and this guard (`data`, was `preAuth`).
+
+  ## Testing
+  - **`page check` and `page shot` anywhere the project is served** (`@plitzi/cli`): `--url <origin>` for a second server
+    of it, staging or a deploy, instead of `npm start`'s port; `page check --space <module>` holds the pages to that space
+    instead of the project's — an agent's page — authored with `authorIsolated`.
+  - **A route with a query is checked as its page** (`@plitzi/cli`): `page check "/?v=2"` matched the query as part of
+    the path, found no page, and checked the space's "not found" page in its place.
+
+  - **What an element that chooses its children draws is checked** (`@plitzi/sdk-authoring`, `@plitzi/cli`): with
+    `choosesChildren`, the page checks owed none of its children — and checked none of them either: a dashboard drawing
+    three panels reported `checked: 1`. Each child it may draw, and what is inside one under no condition of its own,
+    now carries `shownWith` (the child it comes with) on its handle: once that child is on screen it and everything
+    named in it are owed like the rest of the page, and `checked` counts them. `onScreenIfChosen(handles, page)` lists
+    them.
+  - **A page that met a server error is looked at once more** (`@plitzi/cli`): `page check` and `verify` failed a page
+    for a `500` from somebody else's service having a bad second (`/fn/<space>/weather`), and passed on the next run with
+    nothing changed. A page whose requests got a `5xx` is checked again once; its report is the second look, and says
+    what failed the first time (`retriedAfter`). A `4xx` fails the same way twice, and is never retried.
+
+  ## Plugins
+  - **`useNotify`** (`@plitzi/plitzi-sdk`): a plugin shows the page's notifications — `notify('Deleted 79 recordings', {
+appearance: 'danger' })` — the same toasts an `addNotification` step shows, in the space's theme and `notifications`
+    look, with no trigger, flow or `window` event of the space's to wire. The step's vocabulary (`NOTIFICATION_PLACEMENTS`,
+    `NOTIFICATION_APPEARANCES`, `NOTIFICATION_DEFAULTS`) is one list in `@plitzi/sdk-shared`, read by both.
+  - **`appearance: 'danger'` looks like one** (`@plitzi/plitzi-sdk`): it reached the toast library as a type it does not
+    know, so a danger notification showed neither the error icon nor the colour `notifications.danger` sets.
+    A value a notification does not take — from a flow, or a plugin in plain JavaScript — is set aside by name and said
+    in the console, rather than shown as the default in silence (`readNotificationOptions`, `@plitzi/sdk-shared`).
+  - **`useServerAction`** (`@plitzi/plitzi-sdk`, `@plitzi/sdk-authoring`, `@plitzi/sdk-interactions`,
+    `@plitzi/sdk-server`): a plugin runs one of the space's server actions, awaited —
+    `useServerAction<typeof habitDone>('habits-done')({ id })` answers `{ ok, output }` or `{ ok: false, reason, error }`
+    — through the `runServerAction` step itself: the same access, refusals, session handling and dev-tools entry.
+    `defineAction` keeps the literal types of its `call` way in, so the input is typed by the fields it declares (the
+    required ones required); `taskAction` types both ends from the task's `run`, and `FunctionTask<T, R>` takes what
+    `run` answers. `CallInputOf` / `CallOutputOf` read them. One operation is one action, never a `case` in one route.
+    What a run answers is typed (`ServerActionStatus`): a status the server never uses reads as a run that did not
+    complete, never as one that did.
+    The key those types ride under (`CALL_TYPES`) is exported, by `@plitzi/sdk-shared` and `@plitzi/sdk-authoring` with
+    `TypedActionEntry`, `CallInputOf` and `CallOutputOf`: a package that emits declarations could not write the type of an
+    action it exports (`TS4023` on every `export const actions = [defineAction(…)]`).
+  - **A plugin is drawn on the server first** (docs): a preference per device belongs in kept state (`keepState`,
+    `paintedState`) as a bound prop, never read from `localStorage` while rendering — React discards the whole tree on the
+    mismatch, and only in the browser of whoever saved something. `@plitzi/plitzi-ui` is not the page's: a plugin
+    importing it bundles its own copy, with its own contexts and its own look. The authoring skill's `plugin-reach.md`
+    says what a plugin says and to whom: a notification, another element (an event and the space's flow), a server
+    action, shared state, other pages.
+
+  ## Realtime
+  - **A channel that retains** (`@plitzi/sdk-shared`, `@plitzi/sdk-server`, `@plitzi/sdk-elements`): declared
+    `retain: true` (with `publish: 'server'`, which authoring requires), the server keeps the latest message of each type
+    on a topic — said by `ctx.publish` or a flow's `realtime.publish` — and hands them to every page that joins, marked
+    `retained`. A page reads them as `<channel>.retained.<type>`, a plugin as `useChannel(topic).retained`, the newest of
+    a type holding whichever order they arrive in; `null` forgets a type. Kept in the store the actions' `kv` uses (beside
+    the grants, by compare-and-swap), so every replica hands out the same; a topic keeps at most 64 types and 512 KB, and
+    a publish past that is refused before anything is sent. State every screen shares is one publish and one binding —
+    no kv key, initial read or copy in `state` of the project's own. The fleet store `realtime.grants` is now
+    `realtime.kv`.
+  - **The MCP writes every field a channel takes** (`@plitzi/sdk-mcp`): `patchSettings`'s channel had no `grant` — which
+    the guide taught — nor `retain` or the limits, so an agent could not declare a private channel at all. All are there
+    now, and the guide says what `retain` is for and that `channel_<id>.retained` holds it.
+
+  ## Authoring
+  - **`plitzi explain` knows every `@plitzi` package installed** (`@plitzi/cli`): a name that was not
+    `@plitzi/sdk-authoring`'s (`createServer`, `createJsonAdapters`, `useChannel`) was answered as the project's own code,
+    to `grep` in `src/`. It is read from the published types of every one installed, through their re-exports and entry
+    points (`@plitzi/sdk-server/handlers`), and a name two packages export — `createServer` is sdk-server's and sdk-mcp's
+    — is answered with both.
+
+  - **A space module somebody else wrote, authored where it reaches nothing** (`@plitzi/sdk-authoring`):
+    `authorIsolated(file, { timeoutMs })` of `@plitzi/sdk-authoring/node` runs `authorSpace` on it in a process Node's
+    permission model holds to reading the module's folder and its packages — no file written, no process started, no
+    variable of the caller's environment — kills one that runs too long, and validates what it answers again, so a forged
+    answer gains nothing. A refusal comes back as `authorSpace` says it, with the problems as data.
+  - **Pages an agent writes, served** (`@plitzi/sdk-server`): `createAuthoringHost({ dir, frameAncestors })` serves each
+    space it is handed at an address of its own (`put(space, { id }) → /?__pt=<id>`) as a draft of its one space, kept in
+    `dir` across restarts; `drop(id)` forgets one, and anything else answers `404` saying where the pages are.
+  - **A space is chosen by host or credential** (`@plitzi/sdk-server`, docs): `getSpaceDeployment` is asked on every
+    request, and what a page fetches after it carries nothing of its address but the host — a space chosen by the page's
+    query or path lost everything it asked for, and `/_plitzi/space/<hash>.json` answered a bare `404`. The contract and
+    the README say so (the README offered "by path prefix"), and that `404` says why.
+
+  - **`plitzi explain on` says how to read what a trigger carries** (`@plitzi/sdk-authoring`): its doc sat above a
+    helper, so `explain` printed only the signature. It now leads with `[named('picked', on('onPick')), …('{{ picked.seat
+}}')]`, and the CLI skill's plugin section says the same.
+
 ## 0.38.14
 
 ### Patch Changes

package/dist/authoring/declare.d.ts

@@ -71,7 +71,8 @@ export interface ElementDeclarationData {
     /**
      * Whether the element shows only some of the children put inside it, chosen as it runs — a dashboard showing the
      * panels of the layout saved for this device, a wizard its current step. Read by the page checks, which then owe none
-     * of them on screen; what it draws is still read by the checks of the whole page — images, overflow, legibility.
+     * of them on screen; the ones it draws are checked like the rest of the page — there, visible, and what is named
+     * inside them too.
      */
     choosesChildren?: boolean;
     /**

package/dist/authoring/index.mjs

@@ -2,5 +2,5 @@ import { toBuilderParams as e, toInteractionCallback as t, toInteractionCallback
 import { definePlugin as r, elementDeclaration as i, valuesOf as a } from "./declare.mjs";
 import { BUILTIN_PARAM_TYPES as o, hiddenParams as s, invalidParams as c, missingRequiredParams as l, reconcileParams as u } from "./paramSpec.mjs";
 import { BUILTIN_ELEMENT_CALLBACKS as d, SCROLL_CALLBACKS as f, applyElementCallback as p, getElementCallback as m } from "./elementCallbacks.mjs";
-import { spaceCallbacks as h } from "./spaceCallbacks.mjs";
-export { d as BUILTIN_ELEMENT_CALLBACKS, o as BUILTIN_PARAM_TYPES, f as SCROLL_CALLBACKS, p as applyElementCallback, r as definePlugin, i as elementDeclaration, m as getElementCallback, s as hiddenParams, c as invalidParams, l as missingRequiredParams, u as reconcileParams, h as spaceCallbacks, e as toBuilderParams, t as toInteractionCallback, n as toInteractionCallbacks, a as valuesOf };
+import { NOTIFICATION_APPEARANCES as h, NOTIFICATION_DEFAULTS as g, NOTIFICATION_PLACEMENTS as _, readNotificationOptions as v, spaceCallbacks as y } from "./spaceCallbacks.mjs";
+export { d as BUILTIN_ELEMENT_CALLBACKS, o as BUILTIN_PARAM_TYPES, h as NOTIFICATION_APPEARANCES, g as NOTIFICATION_DEFAULTS, _ as NOTIFICATION_PLACEMENTS, f as SCROLL_CALLBACKS, p as applyElementCallback, r as definePlugin, i as elementDeclaration, m as getElementCallback, s as hiddenParams, c as invalidParams, l as missingRequiredParams, v as readNotificationOptions, u as reconcileParams, y as spaceCallbacks, e as toBuilderParams, t as toInteractionCallback, n as toInteractionCallbacks, a as valuesOf };

package/dist/authoring/spaceCallbacks.d.ts

@@ -1,4 +1,33 @@
 import { BuiltinGlobalCallback } from './builder';
+/** Where a notification may appear: the `addNotification` step's `placement`, and `useNotify`'s. */
+export declare const NOTIFICATION_PLACEMENTS: readonly ["top-right", "top-center", "top-left", "bottom-right", "bottom-center", "bottom-left"];
+export type NotificationPlacement = (typeof NOTIFICATION_PLACEMENTS)[number];
+/** How a notification looks: the `addNotification` step's `appearance`, and `useNotify`'s. */
+export declare const NOTIFICATION_APPEARANCES: readonly ["success", "danger", "warning", "info"];
+export type NotificationAppearance = (typeof NOTIFICATION_APPEARANCES)[number];
+/** What a notification takes besides its text — every one with the default the `addNotification` step has. */
+export type NotificationOptions = {
+    placement?: NotificationPlacement;
+    appearance?: NotificationAppearance;
+    autoDismiss?: boolean;
+    /** Milliseconds before it dismisses itself, with `autoDismiss`. */
+    autoDismissTimeout?: number;
+};
+/**
+ * What a notification was handed, kept to what it takes — a flow's values arrive as written, and a plugin may be plain
+ * JavaScript — with each field set aside named, so the caller says so rather than showing the default in silence.
+ */
+export declare const readNotificationOptions: (given: Readonly<Record<string, unknown>>) => {
+    options: NotificationOptions;
+    ignored: string[];
+};
+/** The defaults of a notification, the step's and the hook's alike. */
+export declare const NOTIFICATION_DEFAULTS: {
+    readonly placement: "top-right";
+    readonly appearance: "success";
+    readonly autoDismiss: true;
+    readonly autoDismissTimeout: 5000;
+};
 /**
  * The `space` source, which the SDK application registers rather than this package.
  *

package/dist/authoring/spaceCallbacks.mjs

@@ -1,5 +1,38 @@
 //#region src/authoring/spaceCallbacks.ts
-var e = { addNotification: {
+var e = [
+	"top-right",
+	"top-center",
+	"top-left",
+	"bottom-right",
+	"bottom-center",
+	"bottom-left"
+], t = [
+	"success",
+	"danger",
+	"warning",
+	"info"
+], n = (n) => {
+	let r = e.find((e) => e === n.placement), i = t.find((e) => e === n.appearance), { autoDismiss: a, autoDismissTimeout: o } = n, s = typeof o == "number" && Number.isFinite(o) && o > 0 ? o : void 0, c = {
+		placement: r !== void 0,
+		appearance: i !== void 0,
+		autoDismiss: typeof a == "boolean",
+		autoDismissTimeout: s !== void 0
+	};
+	return {
+		options: {
+			...r === void 0 ? {} : { placement: r },
+			...i === void 0 ? {} : { appearance: i },
+			...typeof a == "boolean" ? { autoDismiss: a } : {},
+			...s === void 0 ? {} : { autoDismissTimeout: s }
+		},
+		ignored: Object.entries(c).filter(([e, t]) => !t && n[e] !== void 0).map(([e]) => e)
+	};
+}, r = {
+	placement: "top-right",
+	appearance: "success",
+	autoDismiss: !0,
+	autoDismissTimeout: 5e3
+}, i = { addNotification: {
 	source: "space",
 	title: "Add Notification",
 	strictParams: !0,
@@ -12,40 +45,28 @@ var e = { addNotification: {
 		placement: {
 			type: "select",
 			description: "Where the toast appears on screen.",
-			default: "top-right",
-			options: [
-				"top-right",
-				"top-center",
-				"top-left",
-				"bottom-right",
-				"bottom-center",
-				"bottom-left"
-			]
+			default: r.placement,
+			options: [...e]
 		},
 		appearance: {
 			type: "select",
 			description: "Visual style of the notification: success, danger, warning or info.",
-			default: "success",
-			options: [
-				"success",
-				"danger",
-				"warning",
-				"info"
-			]
+			default: r.appearance,
+			options: [...t]
 		},
 		autoDismiss: {
 			type: "boolean",
 			description: "Whether the notification dismisses itself after a timeout.",
-			default: !0,
+			default: r.autoDismiss,
 			canBind: !1
 		},
 		autoDismissTimeout: {
 			type: "number",
 			description: "Milliseconds before auto-dismiss. Only applies when autoDismiss is true.",
-			default: 5e3,
+			default: r.autoDismissTimeout,
 			when: (e) => e.autoDismiss === !0
 		}
 	}
 } };
 //#endregion
-export { e as spaceCallbacks };
+export { t as NOTIFICATION_APPEARANCES, r as NOTIFICATION_DEFAULTS, e as NOTIFICATION_PLACEMENTS, n as readNotificationOptions, i as spaceCallbacks };

package/dist/realtime/topics.mjs

@@ -14,9 +14,9 @@ var t = /^[A-Za-z0-9:_.-]{1,128}$/, n = "[A-Za-z0-9_.-]{1,64}", r = (e) => t.tes
 ]), c = (t, n) => {
 	let r = [];
 	if (o.test(t) || r.push("a pattern is letters, digits and `:_.-`, with `{name}` for the part a page fills in — `board:{id}`"), !e(n)) return [...r, "a channel is an object: `{ access: { mode: \"public\" } }`"];
-	let { access: i, publish: a, presence: c, grant: l, maxMessageBytes: u, messagesPerSecond: d } = n, f = e(i) ? i.mode : void 0;
-	typeof f != "string" || !s.has(f) ? r.push("`access` is { mode: \"public\" }, { mode: \"session\" } or { mode: \"role\", permissions: […] }") : f === "role" && !(e(i) && Array.isArray(i.permissions) && i.permissions.every((e) => typeof e == "string")) && r.push("`access: { mode: \"role\" }` names the permissions it needs: `permissions: [\"boardEdit\"]`"), a !== void 0 && a !== "clients" && a !== "server" && r.push("`publish` is \"clients\" (pages send) or \"server\" (only a flow's realtime.publish)"), c !== void 0 && typeof c != "boolean" && r.push("`presence` is true or false"), l !== void 0 && typeof l != "boolean" && r.push("`grant` is true (a page needs a grant from `realtime.grant` to open a topic) or false");
-	for (let [e, t] of [["maxMessageBytes", u], ["messagesPerSecond", d]]) t !== void 0 && (typeof t != "number" || !Number.isInteger(t) || t <= 0) && r.push(`\`${e}\` is a whole number above zero`);
+	let { access: i, publish: a, presence: c, grant: l, retain: u, maxMessageBytes: d, messagesPerSecond: f } = n, p = e(i) ? i.mode : void 0;
+	typeof p != "string" || !s.has(p) ? r.push("`access` is { mode: \"public\" }, { mode: \"session\" } or { mode: \"role\", permissions: […] }") : p === "role" && !(e(i) && Array.isArray(i.permissions) && i.permissions.every((e) => typeof e == "string")) && r.push("`access: { mode: \"role\" }` names the permissions it needs: `permissions: [\"boardEdit\"]`"), a !== void 0 && a !== "clients" && a !== "server" && r.push("`publish` is \"clients\" (pages send) or \"server\" (only a flow's realtime.publish)"), c !== void 0 && typeof c != "boolean" && r.push("`presence` is true or false"), l !== void 0 && typeof l != "boolean" && r.push("`grant` is true (a page needs a grant from `realtime.grant` to open a topic) or false"), u !== void 0 && typeof u != "boolean" ? r.push("`retain` is true (the server keeps the latest message of each type for pages that join) or false") : u === !0 && a !== "server" && r.push("`retain: true` keeps what the server says, so only the server may speak: add `publish: \"server\"` — a page changes it through an action");
+	for (let [e, t] of [["maxMessageBytes", d], ["messagesPerSecond", f]]) t !== void 0 && (typeof t != "number" || !Number.isInteger(t) || t <= 0) && r.push(`\`${e}\` is a whole number above zero`);
 	return r;
 }, l = (e) => ({
 	maxMessageBytes: e.maxMessageBytes ?? 4096,

package/dist/types/ActionTypes.d.ts

@@ -17,6 +17,43 @@ export type ActionField = {
     /** Shown in the builder, and read by the MCP agent when it wires a call. */
     label?: string;
 };
+/** What a caller sends for a field of a type: text for `text`, `date` and `file`, anything parseable for `json`. */
+type ActionFieldValue<T extends ActionFieldType> = T extends 'number' ? number : T extends 'boolean' ? boolean : T extends 'json' ? unknown : string;
+/** The input a caller hands an action, from the fields it declares: those `required: true` must be there. */
+export type ActionInputOf<Fields extends Readonly<Record<string, ActionField>>> = {
+    -readonly [K in keyof Fields as Fields[K]['required'] extends true ? K : never]: ActionFieldValue<Fields[K]['type']>;
+} & {
+    -readonly [K in keyof Fields as Fields[K]['required'] extends true ? never : K]?: ActionFieldValue<Fields[K]['type']>;
+};
+/**
+ * The key a typed action's input and output ride under, in its type only — nothing holds it at run time. Exported so a
+ * package that emits declarations can name the type of an action it exports (`export const actions = [defineAction(…)]`):
+ * a symbol it cannot import is one its `.d.ts` cannot write (TS4023).
+ */
+export declare const CALL_TYPES: unique symbol;
+/**
+ * An action whose `call` way in is known to the types — what it takes and what it answers: what `defineAction` and
+ * `taskAction` answer, so a page that runs it (`useServerAction<typeof saveHabit>('save-habit')`) is held to the input
+ * it declares and handed the output typed. Nothing of it exists at run time — the action is the same document.
+ */
+export type TypedActionEntry<Input, Output = unknown> = ActionEntry & {
+    readonly [CALL_TYPES]?: {
+        input: Input;
+        output: Output;
+    };
+};
+/** The input an action's `call` way in takes, from its type — any object, for an action whose type does not say. */
+export type CallInputOf<Action> = Action extends {
+    readonly [CALL_TYPES]?: {
+        input: infer Input;
+    };
+} ? unknown extends Input ? Record<string, unknown> : Input : Record<string, unknown>;
+/** What an action answers, from its type — `unknown` for one whose type does not say. */
+export type CallOutputOf<Action> = Action extends {
+    readonly [CALL_TYPES]?: {
+        output: infer Output;
+    };
+} ? Output : unknown;
 /**
  * Who may start a run through ONE way in. Resolved against the auth kernel — never re-implemented here.
  *
@@ -709,3 +746,4 @@ export type ActionJobQueue = {
         olderThan?: string;
     }) => Promise<number>;
 };
+export {};

package/dist/types/RealtimeTypes.d.ts

@@ -22,6 +22,13 @@ export type ChannelDeclaration = {
      * a locked board.
      */
     grant?: boolean;
+    /**
+     * Whether the server keeps the latest message of each type on a topic, and hands them to every page that joins: state
+     * all the screens share — a dashboard's lists, a board's settings — said once by the server (`ctx.publish`, a flow's
+     * `realtime.publish`) and there for a page that opens later, as `<channel>.retained.<type>`. Kept until the next of
+     * its type; `null` forgets it. Only on a channel the server alone publishes on (`publish: 'server'`).
+     */
+    retain?: boolean;
     /** The largest `data` a page may send, as JSON bytes. 4 KB when absent. */
     maxMessageBytes?: number;
     /** How many messages one connection may send a second. 30 when absent. */
@@ -55,6 +62,11 @@ export type RealtimeMessage = RealtimeSender & {
      * knows it for its own by `from` — its channel's `me`. Without it, a page never hears what it sent.
      */
     echo?: true;
+    /**
+     * Kept by the server: on a `retain: true` channel, the latest message of its type — sent as it is said, and again to
+     * every page that joins. The newest of a type is the one that holds; `null` data forgets it.
+     */
+    retained?: true;
 };
 /** What a page asks of a publish beyond the message itself. */
 export type RealtimePublishOptions = {

package/dist/types/ServerTypes.d.ts

@@ -359,8 +359,15 @@ export type SSRAdapters = {
      *  dedicated MCP server renders nothing, reads schema and style through its own adapters, and had to hand this
      *  one over anyway for the type to be satisfied — an adapter it never called. */
     getOfflineData?: (spaceId: number, environment: string, revision?: number) => Promise<OfflineDataRaw | undefined>;
-    /** Which space, environment and revision a request resolves to. Optional here for the same reason as
-     *  `getOfflineData`: MCP resolves its space from the request token (`getGrant`), never from the host. */
+    /**
+     * Which space, environment and revision a request resolves to. Optional here for the same reason as
+     * `getOfflineData`: MCP resolves its space from the request token (`getGrant`), never from the host.
+     *
+     * Asked on EVERY request, not only a page's: what the page fetches after it — `/_plitzi/space/<hash>.json`, `/_action`,
+     * `/fn/…`, `/_realtime` — is resolved again, and carries nothing of the page's address but its host (and the
+     * visitor's credentials). So a space is chosen by the host — a domain, a sub-domain (`wildcardSubdomain`) — or by a
+     * credential (`authoringPreview`): one chosen by the page's path or query is lost on the requests that follow it.
+     */
     getSpaceDeployment?: (req: SSRRequest) => Promise<SSRSpaceDeployment>;
     /** Resolve the grant the MCP request operates under, from the verified `Authorization` bearer. The consumer
      *  owns the JWT secret and the authorization model, so it decides here; the MCP service stays stateless.
@@ -1033,6 +1040,19 @@ export type SSRServerConfig = {
     };
     /** Realtime channels the spaces declare — see {@link SSRRealtimeConfig}. On, in memory, when absent. */
     realtime?: SSRRealtimeConfig;
+    /**
+     * The writes a page on another site may cause here. None, by default: a browser's POST, PUT, PATCH or DELETE that it
+     * says another site caused (`Sec-Fetch-Site: cross-site`, or a foreign `Origin`) is refused 403 `reason: 'foreign'` —
+     * a session cookie or none, because a server holding credentials of its own, or a tool nobody signs in to, acts for
+     * whoever reaches it. A request with `Authorization`, and one that is not a browser's (a webhook, a script), are never
+     * asked. With `auth`, the deployment's `identity.platformOrigins` count as its own too.
+     */
+    crossSiteWrites?: {
+        /** Origins whose pages may write here, exactly as a browser sends them — `https://app.example.com`. */
+        origins?: string[];
+        /** Paths any site may post to: a form other sites embed by design. */
+        paths?: (path: string) => boolean;
+    };
     /** Connector manifest and credential lookups — see {@link ConnectorLookupsConfig}. They serve the RSC read path
      *  and the `/_action` write endpoint alike; without them neither can reach a connector. */
     connectors?: ConnectorLookupsConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plitzi/sdk-shared",
-  "version": "0.38.14",
+  "version": "0.38.15",
   "license": "AGPL-3.0",
   "files": [
     "dist",