@plitzi/sdk-shared 0.38.10 → 0.38.12

package/CHANGELOG.md

@@ -1,5 +1,284 @@
 # @plitzi/sdk-shared
 
+## 0.38.12
+
+### Patch Changes
+
+- 1301338: ## Builder
+
+  - **Icons in the canvas again** (`@plitzi/plitzi-builder`): the canvas inlined the SDK's Font Awesome sheet into its
+    `<style>`, where the sheet's `url(webfonts/…)` resolved against the editor's URL — a `srcdoc` frame takes it as its
+    base — so every icon was a 404 under `/spaces/<space>/webfonts/` and drew as an empty box. Only the Vite dev server,
+    which rewrites the URL, hid it. The canvas and the element preview now link the sheet from where the host serves it:
+    a new prop, `sdkIconsStylePath`, the one the host already gives the pages it renders
+    (`/sdk-assets/plitzi-sdk-icons.css` for sdk-server). Absent, the canvas links no icon sheet.
+
+  ## Plugins
+  - **A plugin's other elements, hosted by `custom`** (`@plitzi/sdk-elements`): `custom({ renderType: 'jamDisc' })` on a
+    space with a plugin installed whose main element is another (`plitzi plugin pack` of several folders: the first is the
+    plugin, the rest go in it) rendered "Custom Component jamDisc Not Found" — the page registers only the plugin's main
+    element, and a `custom` host looked nowhere else. It now loads the type from the installed plugin that packs it, as
+    an element of the type itself always did, so the two ways the docs give to place a plugin's element are the same
+    everywhere: in a project `plitzi create` wrote, and once the project is on Plitzi.
+  - **One way to place a plugin's element** (`@plitzi/sdk-authoring`, `@plitzi/cli`, docs): from its declaration,
+    `const seatPicker = defineElement(declaration)` then `seatPicker({ id, … })` — typed by what it
+    declares, and the element the builder adds when somebody drops it. The welcome space `plitzi create` writes, the
+    plugin package's preview, `plitzi plugin add` and `plitzi explain` all write it so (the template's
+    `PluginHostOptions` now takes the plugin's `type` and `declaration: { from, attributes? }`; `custom`/`element` hosting
+    is gone). `pluginFolders(folder)` (`@plitzi/sdk-authoring/node`) reads each plugin with the folder it is in;
+    `pluginDeclarations` is built on it. A `custom({ renderType })` naming a plugin the space was handed the declaration
+    of is offered the declaration instead — suggestion `plugin-custom-host`. `custom` stays for a component registered
+    by name with no declaration. The skills, the CLI README, the MCP guide, `docs/en` and the website say the same.
+  - **`definePlugin`** (`@plitzi/sdk-authoring/plugin`, a new entry of 3 KB with nothing else in it): a plugin's
+    declaration written from what only it can say —
+    `definePlugin<SeatPickerAttributes>()({ type, label, attributes, triggers, callbacks })` — and every other field
+    at the default all plugins share (the builder's gestures, the catalogue entry, each attribute bindable, an empty
+    style). It answers the whole declaration, branded with its attributes, so `defineElement(declaration)` is typed
+    without a generic. `plitzi plugin add` and `create --plugin` write declarations with it (about a third of the lines).
+  - **`usePluginTrigger(declaration)`** (`@plitzi/plitzi-sdk`): fires a plugin's declared event on its element — the
+    event name and what each hands a flow typed off the declaration's `preview` — on a live page only. The hook every
+    plugin wrote for itself (and `plugin add` generated as `use<Name>Events`) is gone from the scaffold.
+  - **Attributes as the types their defaults are** (`@plitzi/sdk-elements`): a plugin's attribute bound from text — a
+    state, a row, a channel message — reaches its component as the number or the flag its declared default is (`'112'`
+    as 112, `'true'` as true). A plugin no longer types its props `number | string` and parses them.
+
+  ## Server actions and functions
+  - **Task params with rules** (`@plitzi/sdk-server`, `@plitzi/sdk-shared`): a task declares `required`, a text's
+    `maxLength` and a number's `min`/`max`, and the runner refuses a call that breaks any of them — every rule broken at
+    once, in the words the page shows (`Title is required; Seconds is at most 300`) — before the code runs. A `text` param
+    bound to a number arrives as its digits. The manifest keeps the rules, so the platform's sandbox checks the same.
+  - **`taskAction(task, { trigger })`** (`@plitzi/sdk-authoring`): the action that runs one of the space's tasks and
+    answers its result, derived from the task — its id (`<namespace>-<action>`), name, description and input (the task's
+    params, once). An action of more than one step is still `defineAction`.
+  - **`ctx.rateLimit(bucket, { …, refuse })`**: past the limit the call is refused with those words instead of answering
+    `allowed: false` for the code to check — natively and in the sandbox.
+
+  ## Authoring
+  - **`runServerActionOrNotify(id, params, fallback)`**: a server action run and the notice the visitor reads when it
+    fails — the action's own refusal, or the fallback — as two steps to spread into a flow.
+  - **`repeated-shape` reads what copies bind**: copies whose bindings read their data in different forms (a count, a
+    total of a quota) and copies holding a provider resolved on the server (found by its own id) are no longer offered
+    as one component.
+  - **`element-color-inherited`** (suggestion): `elements` giving a heading, a text, a link… `color: inherit` or the
+    page's own colour. **A link inherits the page's colour** (`@plitzi/plitzi-sdk`, `@plitzi/sdk-elements`) rather than
+    holding the SDK's grey — the same by default, and the space's palette inside a card that is a link. The template
+    every space starts from writes its colours once, on the page.
+
+  ## Fixes
+  - **A dialog opened with an id** (`@plitzi/sdk-elements`): `openDialog('dialog', '{{ row.id }}')` reads the id as its
+    `content`, as `openModal` already did — a numeric id parsed as the number and the dialog's bindings read nothing.
+  - **A select's chevron** (`@plitzi/plitzi-sdk`): a drawn chevron in the field's own colour, sized by its type, in place
+    of the `▼` glyph — and laid out in the box, so it ends where the box's padding begins whatever that padding is, and
+    the chosen option stops short of it instead of running under it. A disabled select's is faded.
+  - **Every element has its settings** (`@plitzi/plitzi-builder`, `@plitzi/sdk-elements`): the builder found none for
+    `tabContainerHeader` (registered under a misspelt type), `themeToggle`, `dropdownPopup`, `loading` and `notFound`.
+    The theme toggle's panel sets its mode, its labels and whether it offers "System"; the registry is typed by element
+    type and must hold one for each.
+  - **A plugin's panel** (`@plitzi/cli`): `plitzi doctor` warns of a plugin with no `Settings.tsx`, or one its entry never
+    passes as `pluginSettings` (`plugin-settings-missing`); the example `create` writes has its panel, as every element
+    `plugin add` writes does, and the panels it generates are laid out as the project's Prettier lays them out.
+  - **A refused or failed run reaches `onFlowError` in every mode** (`@plitzi/sdk-interactions`): an awaited server
+    action the server refused fired no `onFlowError` on the element that started it, as `detached` and `stream` ones do
+    — a board rolling its edits back on a refusal never did; and a run answered `status: 'failed'` fired `onFlowEnd`
+    (detached) or nothing (awaited) rather than `onFlowError`.
+  - **A source renamed** (`@plitzi/sdk-shared`): the binding picker lists a provider, a form or a modal by the name its
+    element has now, not the one it had when it mounted.
+  - **A text's words in the builder** (`@plitzi/sdk-elements`): a `paragraph`, `text` or `heading` whose `content` is
+    `0` shows `0` while editing too, not its placeholder; one bound to nothing shows nothing rather than `null`.
+  - **Built-in declarations** (`@plitzi/sdk-shared`): `elementDeclaration` fills in what every element shares — the
+    builder's gestures, Plitzi's catalogue entry, a visible element with no bindings, its style named by its label —
+    from the defaults `definePlugin` uses; each element's declaration says only what is its own (a third of the lines).
+
+  ## Typed for plugins and hosts
+  - **`usePlitzi()` and `PlitziProvider`** (`@plitzi/sdk-shared/hooks/usePlitzi`, `@plitzi/plitzi-sdk`): what were
+    `usePlitziServiceContext()` and `PlitziServiceProvider` (and `PlitziServiceContextValue`, now `PlitziContextValue`),
+    holding only what the host rendering a space knows — `settings`, `root`, `utils`. Its `contexts` and
+    `customContexts` are gone: every context it carried is a shared one already, imported from its own module
+    (`@plitzi/sdk-interactions/InteractionsContext`, `@plitzi/sdk-shared/network/NetworkContext`…), and
+    `PluginsContext` moves to `@plitzi/sdk-shared/plugins/PluginsContext` beside the others.
+  - **`InteractionsManagerApi`** (`@plitzi/sdk-shared`): the interactions manager as everything outside
+    `@plitzi/sdk-interactions` reaches it, declared where every package can name it and implemented by
+    `InteractionsManager`, so `use(InteractionsContext)` is typed — `interactionTrigger`, `createChildManager`… — where it
+    was `any`.
+  - **`getPathsFromObject`** (`@plitzi/sdk-shared/helpers/utils`), spelt right; `getPathsFromObeject` is gone.
+  - **`ElementWords` places itself** (`@plitzi/sdk-elements`): `contentPlacement` and the element's children, so a button
+    and a link write their words once.
+
+## 0.38.11
+
+### Patch Changes
+
+- cadf70a: - **`server.cache.invalidate` drops what a page is rendered from** (`@plitzi/sdk-server`): the pages, the RSC answers
+  and the schema data they are rendered from go together. It dropped the pages alone, and the next request rendered
+  the same page again from the schema still cached under the same key — a publish that invalidated the space changed
+  nothing until the schema's TTL ran out. `clear()` and `size` cover the three. A filter on `hostname` drops the schema
+  data too, which belongs to no one host. `server.cache` is `null` only when nothing is cached (`cacheTtlMs: 0` and
+  `rsc.cacheTtlMs: 0`).
+
+  ## Style inspector
+  - **Finds a property** (`@plitzi/sdk-style`): a search above the categories narrows them to the ones that edit what was
+    typed — a CSS name in any order of its words (`border radius` finds the four corners), a category's title, or a
+    common word for it (`bg`, `rounded`) — opens them, and shows the advanced rows when the match lives there. Escape
+    clears it. The categories' properties live in one list (`categoryKeys.ts`) that the dots, the advanced hint and the
+    search all read.
+  - **Rows that fit**: a section with more than two controls puts its label above them and lays them out in as many
+    columns as the panel is wide, instead of one row where every label was cut (`Appearan…`, `Cell Spaci…`, the five
+    scroll-snap controls). A row's label column is 80px.
+  - **Where a value comes from, said quietly**: the label's tint keeps its four meanings — set here, from a token, bound
+    to data, inherited — without the solid blocks of colour; hovering says which (an inherited one names its selector and
+    breakpoint) and that a click resets it, the click shows it by striking the label through. The footer's info icon
+    holds the legend, and its arrow folds every category.
+  - **What is being edited**: an "Editing … › Hover" line under the pickers whenever the rules being written are not the
+    selector's plain ones, with a button back to them. Ancestor, pseudo-element and condition fold behind a toggle —
+    never while one is in use.
+  - The class being edited is the panel's one strong mark (violet), the element's type defaults a softer one; the tools'
+    tabs fit the panel and are reachable from the keyboard.
+
+  - **Lists edited in a popover, all alike**: box and text shadows, transforms, transitions and filters share one row
+    (the CSS it writes, a swatch, a remove button) and one popover (a title, a close button, Escape, the focus moved
+    into it). What none of them could read is now kept and edited as text instead of being replaced with a default — a
+    token for the whole value, `drop-shadow(…)`, `url(#…)`.
+  - **Values read the way CSS writes them**: a shadow with two, three or four lengths and its color on either end;
+    `rgba(…)` inside text shadows and filters no longer split; negative shadow offsets accepted; a transition with any
+    of its parts left out; brightness, contrast and saturation past 1. Transition presets are written as CSS — the
+    preset names (`easeInQuad`) made the browser drop the whole declaration — the curve can be dragged into one of your
+    own, and the preview stops with the editor. `font-color` (not CSS) became `color`.
+  - **Background layers keep what they hold**: a repeating gradient (now a switch), a radial gradient's explicit size, a
+    token or `image-set()` as a layer (a "Custom (CSS)" layer), a one-value position read as CSS reads it (`20%` is
+    `20% center`), lists shorter than the layers repeated as CSS repeats them, an unset repeat read as tiling, two-position
+    stops, negative angles — every one of them was rewritten on the next edit of any layer. Defaults are no longer
+    written back, and "Token values" no longer bakes resolved tokens into the layers.
+  - **A layer's editor in two halves** — what it draws, then where it goes (size, position, tile, attachment, clip,
+    which now offers `text`). The gradient's stops sit on one bar, each a handle that drags or moves with the arrow keys;
+    the stop's color and position below it. Previews and swatches resolve the space's tokens.
+  - Spacing tells margin (dashed, outside) from padding; Border's sides are labelled and readable in the dark theme; a
+    class's menu says what each action does to whom; the Style Manager opens at a size that holds both columns.
+
+  ## Builder
+  - **Shortcuts**: `?` shows every shortcut the builder answers to — the same list the "Nothing selected" card teaches
+    from — and ⌘\ / Ctrl+\ hides both side panels for the canvas alone and brings back the ones that were open. Both
+    work with the canvas focused.
+  - **Panels keep their width**: each side panel opens at the width it was left at; the right one starts at 380px.
+  - **Text no smaller than 11px** across the builder's panels (it went down to 10px in fifty places).
+
+  ## Realtime
+  - **A page hears what it sent when it asks to** (`@plitzi/sdk-shared`, `@plitzi/sdk-server`, `@plitzi/sdk-elements`):
+    `publishOn('room', 'react', data, { echo: true })`, `useChannel().publish(type, data, { echo: true })` and the
+    channel's `publish` callback (`echo`) hand the message back to the page that sent it too, once the server took it —
+    stamped like everyone's, with `echo: true`, its `from` the channel's `me`. Without it a page still never hears its
+    own messages, and the docs said "every page on its topic hears it": they now say every OTHER page. Presence never
+    echoes.
+  - **A topic is opened only once it names one** (`@plitzi/sdk-elements`): `useChannel` — and so the `channel` element —
+    opens a topic only when a channel of the space covers it, by the same `matchChannel` the server decides by. A topic
+    written from data that has not arrived (`room:` while its provider loads, or its template still as text) asked the
+    server for both, was refused with a 403 and a console error on every load, and is now waited for.
+  - **Pages that watch** (`@plitzi/sdk-server`, `@plitzi/cli`): a connection whose page carries the `plitzi-observer`
+    cookie hears its topics and says nothing on them — no `$join`, no presence, its publishes taken and dropped.
+    `page check`, `page shot` and `verify` load pages that way, so checking a live site is no longer a visitor walking
+    into a room (`X walked in`, a member more in every picture). `--presence` takes part as a visitor does.
+
+  ## Authoring
+  - **`template-in-value`** (refused): a `{{ }}` inside an attribute that is an object or a list — a provider's
+    `input`, a list's `items`, a plugin's settings — is never evaluated: only an attribute that is text is interpolated,
+    and the page server reads attributes as saved. A provider's `input` also replaced the route param of the same name
+    the action was already given, so `input: { room: '{{ navigation.routeParams.room }}' }` reached the task as `""` and
+    the page answered 404; its refusal says the action is handed the page's route and query params already. Anything
+    else is a binding on the attribute. `mockData`, a sample, is not held to it.
+  - **Rules on top of a class need no `id`** (`class: [card, { gap: '6px' }]`): they are named after the id the element
+    is given, written or not. `modifier-without-id` is gone; a one-off tweak no longer needs a name nothing reads.
+  - **Typed list rows have `inTemplate`**, as untyped ones do, and `bindTemplate`, `visibleWhen`, `hiddenWhen` and
+    `variantFrom` take a typed source's path as well as a name: turning a list typed broke every template of its rows.
+  - **`when({ field, operator: 'empty' })`** takes no `value` (nor `notEmpty`), as flows.md recommends; it did not
+    type-check.
+  - **Data-driven colours**: a style binding on a custom property (`{ to: '--who', category: 'style' }`) is written as
+    named — it was camel-cased into `who` — so a class reads `var(--who, var(--muted))`. A style binding's value carrying
+    `;` or braces is not written: the page server writes inline styles as text, and such a value added declarations of
+    its own. `binding-target-unknown` on `style` or a CSS property says to bind it in the `style` category.
+  - `unknown-attribute` for `decorative` on an `svg` or a `fontAwesome` says what it means: without a `label` it is
+    already hidden from screen readers.
+
+  - **A folder nobody declared says where to declare it**: `folder-undeclared` (a page, a layout, a folder's parent)
+    ends with `pageFolders: [{ id, name }]` on the space, and with the line of the `pageFamily` that wrote the page. A
+    folder starts its pages' addresses (`/docs/quickstart`), so a misspelt one is never declared on the author's behalf.
+    The skill's `pageFamily` example declares its folder.
+  - **A tag is an element**: a `subType` this element has not but another has — `container({ subType: 'ol' })` — names
+    that element (`list({ subType: 'ol' })`) instead of the value two letters away (`dl`). Read off the elements'
+    declarations, for every element and tag.
+  - **A `pageFamily`'s body is written once**: `repeated-shape` and `repeated-on-pages` no longer count the same part of
+    each page of one family as copies — they were offering a component for exactly what the docs recommend. Copies within
+    one page, or across pages written one by one, are still offered.
+  - **Colour emoji are not text to `page check`**: a character painted in its own colours (🎲, `❤️`, a keycap, a ZWJ
+    sequence) is left out of the contrast measure, which compared `color` with the tile behind it and failed `verify`
+    in the theme whose text colour was close to the tile. A symbol drawn as text (✓, ★) is still measured.
+
+  - **`declared-callback-target`** (refused): a value beside `on` in `declaredCallback(…, { on, date })` — written as
+    `openModal`'s target reads — was read nowhere, and the step ran without it. Refused, with the `params` it goes in
+    (`{ on: 'calendar', params: { date } }`) and whether it is one of the callback's declared params.
+  - The skill's list rows show the typed form beside the untyped one: with `items` typed by a sample, `r.item` is a path
+    (`from: r.item.title`), not text to put in a template string.
+  - **`slot-not-class`** (refused): rules written in place in a slot — `slots: { error: [fieldError, { color }] }`, past
+    the type in JavaScript or a spec rebuilt from JSON — were taken for a declaration with no rules, and `authorSpace`
+    failed later with `Cannot read properties of undefined (reading 'desktop')`, naming nothing. Refused where the slot
+    is written, naming the slot and the element, with the `styles()` declaration to hand instead.
+
+  ## CLI
+  - **`page shot --click` (and `--clip`, `--wait-for`, `--scroll-to`, `--steps`) takes any selector**: a value that is
+    not an element's name (letters, digits, `-`, `_`) is a selector, CSS or Playwright's own (`button:has-text("Orbit")`).
+    It was wrapped as a name, and an invalid selector ended the command with Playwright's stack trace; it is now refused
+    with the reason.
+
+  - **`plitzi functions add <package>`**: a package the functions use comes with them, as a function carries its
+    dependencies. Installed in the project, it is bundled (web APIs only, minified, its licence kept) into
+    `src/functions/vendor/<package>.js`, with a `.d.ts` re-exporting the installed package's types, imported as
+    `./vendor/<package>.js` and pushed, built and run with the rest — nothing is resolved anywhere else, so the builder,
+    the sandbox and the push are unchanged. A package that reaches Node (`fs`, `node:*`) is refused, naming what it
+    reached; one past the functions' 1 MB is too; one that reads `process`/`Buffer` is warned about. The build's refusal
+    of a package import now names the command.
+  - **`page shot` targets**: a bare word is an element's name, or — no element named so — a tag (`textarea`); resolved on
+    the loaded page for `--click`, `--clip`, `--scroll-to`, `--wait-for` and `--steps`. In `--steps`, `type` takes a
+    quoted element with spaces (`type ".panel textarea" hola`) — it was cut at its first space and typed the rest — and
+    fails when the click leaves no field focused, rather than sending the keys to the page's shortcuts.
+
+  ## Server
+  - **`server.listen()` resolves once the port answers** (`@plitzi/sdk-server`) — in a fleet, once the first worker
+    does. `serveProject` writes `tmp/dev-server.json` and says `pages on …` after it, not on the line after `listen`:
+    for about 0.4 s a tool trusting the line (CI, Playwright's `webServer`, `page check`) was refused. A port it cannot
+    take still ends the process, or goes to `onListenError`, and the promise is then never resolved.
+  - **Runs set for later** (`@plitzi/sdk-server`, `@plitzi/sdk-shared`, `@plitzi/sdk-authoring`, `@plitzi/plitzi-builder`):
+    a turn that runs out, a bot's move, a hold that lapses — one run starting one of the space's actions in N seconds,
+    whether or not a page is still open. The action says it may be with a **`later` trigger** (no access rule: the run
+    that set it was let in); a flow sets it with `flow.later { action, in, input, key }`, a function with
+    `ctx.later({ … })`, and `flow.cancelLater` / `ctx.cancelLater(key)` drops it. A `key` names it: set again under the
+    same key, the one still waiting is replaced — the newer of two set at once, on every replica — and a running one is
+    left. It is a job of the queue schedules use: due by the store's clock (0 s to 30 days, about a second late at most),
+    once across replicas, retried, shown in Automations → Queue. Refused before anything is queued, with why: no `later`
+    trigger, one switched off, a time out of range, a key that is not one, a server with no jobs. A plugin's functions
+    set none. `ActionJobQueue` gains `cancelPending({ spaceId, key, olderThan? })` and jobs a `key`: the memory, Mongo
+    and MySQL queues implement it, and the shared contract tests it. **MySQL**: `action_jobs` gains `job_key` (and the
+    `action_jobs_key` index), added on first use; with `createTables: false`, run that statement of
+    `mysqlJobSchemaUpgrades()`. A queue of a deployment's own implements `cancelPending` (`09-schedules` shows one).
+  - **A project's `kv` file has one holder** (`@plitzi/sdk-server`): `createFileKv` takes `<file>.lock` with its pid;
+    a second process — another `npm start`, a `--watch` left running — is refused, naming the first (`the server of
+"orbita", on port 8080`) instead of both writing their whole map over each other's changes, and a lock whose process
+    is gone is taken over. `close()` writes what is pending and lets go. A server with `workers` opens the file once, in
+    the primary, and its workers reach it through the fleet (`fleetKv`): each used to open a copy of its own.
+  - **A self-hosted project's credentials** (`@plitzi/sdk-server`, `@plitzi/cli`): `serveProject` answers
+    `getCredential` from `PLITZI_CREDENTIALS` in `.env` — one JSON object, credential id → its keys — so
+    `ctx.fetch({ credential })`, a connector and an `http.request` step work on the project's own server, not only in
+    `functions dev`. The same variable for both (it was `PLITZI_FUNCTIONS_CREDENTIALS`, read by the CLI alone); a value
+    that is not that object is refused with how to write it, instead of every credential going missing.
+  - **`HOST` beyond loopback says where to open it**: with `HOST=0.0.0.0`, `serveProject` prints the machine's network
+    addresses — what a tablet on the same Wi-Fi opens — and that anyone on that network can. `.env.example` names `HOST`
+    and `PLITZI_CREDENTIALS`.
+
+  ## SDK
+  - **`useElementSize(ref)`** (`@plitzi/plitzi-sdk`): the size a plugin's own box is drawn at, followed as it changes —
+    what `useDisplayMode()` cannot say: a tablet held upright is `mobile` by the window and still a week wide by the
+    plugin's box. `undefined` until measured, so the server's page and the hydrated one agree. The breakpoints are
+    unchanged.
+  - The functions docs say how a task's `params` types (how the builder edits them: `codemirror-json`) and an action's
+    `input` types (what the value is: `json`) correspond.
+
 ## 0.38.10
 
 ### Patch Changes

package/dist/actions/validateDocument.mjs

@@ -18,6 +18,7 @@ var s = [
 	"call",
 	"webhook",
 	"schedule",
+	"later",
 	"render",
 	"custom"
 ], u = ["sha256", "sha1"], d = /* @__PURE__ */ new Set([
@@ -78,7 +79,7 @@ var s = [
 			message: "is not valid JSON"
 		}) : h(e, `${g}.params.input`, d);
 	}
-	if (_ !== "schedule") {
+	if (_ !== "schedule" && _ !== "later") {
 		if (!p(v.access) || !c.includes(v.access)) d.push({
 			path: `${g}.params.access`,
 			message: "must say who may start a run this way",

package/dist/authoring/declare.d.ts

@@ -1,6 +1,7 @@
-import { InteractionCallback } from '../types/InteractionTypes';
+import { InteractionCallback, InteractionCallbackPreviews } from '../types/InteractionTypes';
 import { PluginBuilder, PluginSchema } from '../types/PluginTypes';
 import { ElementDefinition } from '../types/SchemaTypes';
+import { DisplayMode, StyleAttributes } from '../types/StyleTypes';
 /**
  * How an element says what it can be authored with.
  *
@@ -148,5 +149,154 @@ export type AuthorableAttributes<Props, Injected extends keyof Props = never> =
 export declare const valuesOf: <T extends string>() => <const V extends readonly T[]>(values: V & ([Exclude<T, V[number]>] extends [never] ? unknown : {
     readonly missing: Exclude<T, V[number]>;
 })) => readonly string[];
-export declare const elementDeclaration: <A>() => <const D extends ElementDeclarationData>(declaration: D) => D & ElementAttributesBrand<A>;
+/** What a built-in element writes in its declaration's `content`: what is its own — the rest is filled in. */
+export interface ElementContentSpec {
+    attributes: Record<string, unknown>;
+    /** Left out: `type` (the declaration's), no bindings, visible, and the `base` style selector beside its own. */
+    definition: Omit<Partial<ElementDefinition>, 'type' | 'rootId' | 'parentId' | 'interactions' | 'runtime' | 'styleSelectors'> & {
+        label: string;
+        /** What the element is for, in a sentence: the builder shows it, and an agent reads it to choose the element. */
+        description?: string;
+        styleSelectors?: Record<string, string>;
+    };
+    /** Left out, every gesture, and children of any type. */
+    builder?: PluginBuilder;
+    /** Its place in the catalogue; the rest is Plitzi's own entry. */
+    market: {
+        category: string;
+        icon: string;
+    };
+    /** Left out: named by its label, for desktop. */
+    defaultStyle: {
+        name?: string;
+        displayMode?: DisplayMode;
+        style: StyleAttributes;
+        /** A style of its own for each `subType` — a heading's `h1`… — written whole. */
+        subTypes?: Record<string, {
+            name: string;
+            displayMode: DisplayMode;
+            style: StyleAttributes;
+        }>;
+    };
+    settings?: Record<string, string | number | boolean>;
+}
+/** What {@link elementDeclaration} takes: the declaration as written, `content` holding only what is the element's. */
+export interface ElementDeclarationSpec extends Omit<ElementDeclarationData, 'content'> {
+    content: ElementContentSpec;
+}
+/** What {@link elementDeclaration} fills in, typed as the declaration then carries it. */
+export interface ElementContentDefaults {
+    definition: {
+        type: string;
+        bindings: NonNullable<ElementDefinition['bindings']>;
+        initialState: Record<string, unknown>;
+        styleSelectors: Record<string, string> & {
+            base: string;
+        };
+    };
+    builder: Required<PluginBuilder>;
+    market: {
+        owner: string;
+        verified: boolean;
+        license: string;
+        website: string;
+        backgroundColor: string;
+    };
+    defaultStyle: {
+        name: string;
+        displayMode: DisplayMode;
+    };
+    settings: Record<string, string | number | boolean>;
+}
+/** A built-in element's whole declaration: what it wrote, what was filled in, and the attributes it accepts. */
+export type DeclaredElement<D extends ElementDeclarationSpec, A> = D & {
+    content: ElementContentDefaults;
+} & ElementAttributesBrand<A>;
+/**
+ * A built-in element's declaration, written from what is its own — its type, words, attributes, style, place in the
+ * catalogue — with the rest at the defaults every element shares: the builder's gestures, Plitzi's catalogue entry,
+ * a visible element with no bindings, its style named by its label.
+ *
+ * Called twice, as {@link definePlugin} is: the first call takes the attributes the element accepts, the second the
+ * declaration.
+ */
+export declare const elementDeclaration: <A>() => <const D extends ElementDeclarationSpec>(declaration: D) => DeclaredElement<D, A>;
+/** An event a plugin fires, as {@link definePlugin} takes it: what a flow it starts reads (`preview`) — the rest derived. */
+export type PluginTriggerSpec = {
+    /** Left out, the event's name in words: `onEdit` is "On Edit". */
+    title?: string;
+    /** What a flow started by it reads, `{ ops: '' }` — and so what the plugin hands it (`usePluginTrigger`). */
+    preview?: InteractionCallbackPreviews;
+    params?: InteractionCallback['params'];
+};
+/** An action a plugin answers, as {@link definePlugin} takes it: its params — the rest derived. */
+export type PluginCallbackSpec = {
+    title?: string;
+    params?: InteractionCallback['params'];
+};
+type PluginContent<A extends object> = PluginDeclaration<A>['content'];
+/** What a plugin is, said once: {@link definePlugin} writes the rest of its declaration from it. */
+export interface PluginSpec<A extends object, T extends Record<string, PluginTriggerSpec>, C extends Record<string, PluginCallbackSpec>> extends Omit<ElementDeclarationData, 'type' | 'triggers' | 'callbacks' | 'content'> {
+    /** What a space names it by — the element type. Renaming it orphans every one. */
+    type: string;
+    /** What the builder's catalogue calls it. */
+    label: string;
+    /** What it is for, in a sentence: the builder shows it, and an agent reads it to choose the element. */
+    description?: string;
+    /** Its starting attributes: the component's defaults. */
+    attributes: A;
+    triggers?: T;
+    callbacks?: C;
+    /** What the builder lets a person do with it. Left out, every gesture, and no children. */
+    builder?: PluginBuilder;
+    /** How the catalogue shows it. Left out, under its label, by nobody, MIT. */
+    market?: Partial<PluginContent<A>['market']>;
+    /** The attributes a data source may be pointed at. Left out, every one. */
+    bindable?: readonly (keyof A & string)[];
+    /** Its style before anybody styles it. */
+    style?: PluginSchema['defaultStyle']['style'];
+    /** More of the element's definition — children it starts with (`items`), its style selectors. */
+    definition?: Partial<PluginContent<A>['definition']>;
+    settings?: PluginContent<A>['settings'];
+}
+/** A plugin's events and actions as its declaration carries them: each named by its key, its preview kept as written. */
+export type DeclaredTriggers<T extends Record<string, PluginTriggerSpec>> = {
+    [K in keyof T & string]: Omit<InteractionCallback, 'action' | 'preview'> & {
+        action: K;
+        preview: T[K]['preview'] extends object ? T[K]['preview'] : Record<string, never>;
+    };
+};
+export type DeclaredCallbacks<C extends Record<string, PluginCallbackSpec>> = {
+    [K in keyof C & string]: Omit<InteractionCallback, 'action'> & {
+        action: K;
+    };
+};
+/** What {@link definePlugin} answers: the declaration, its events and actions named, and its attributes in its type. */
+export type DefinedPlugin<A extends object, T extends Record<string, PluginTriggerSpec>, C extends Record<string, PluginCallbackSpec>> = Omit<PluginDeclaration<A>, 'triggers' | 'callbacks'> & {
+    triggers: DeclaredTriggers<T>;
+    callbacks: DeclaredCallbacks<C>;
+} & ElementAttributesBrand<A>;
+/**
+ * A plugin's declaration, written from what only it can say — its type, its words, its attributes, what it fires and
+ * answers — with everything else at the default every plugin shares: the builder's gestures, the catalogue entry, a
+ * bindable attribute for each one, an empty style.
+ *
+ * ```ts
+ * export default definePlugin<SeatPickerAttributes>()({
+ *   type: 'seatPicker',
+ *   label: 'Seat Picker',
+ *   description: 'Picks a seat from a plan.',
+ *   attributes: { start: 0, label: 'Seats' },
+ *   triggers: { onPick: { preview: { seat: '' } } },
+ *   callbacks: { reset: {} }
+ * });
+ * ```
+ *
+ * Called twice, as `elementDeclaration` is: the first call takes the attributes the element accepts (its component's
+ * props, minus what the runtime supplies), which TypeScript cannot read off defaults that leave some out; the second the
+ * rest, whose events it reads as written. The whole declaration comes back — what the build writes into the manifest
+ * and the builder reads — branded with the attributes, so `defineElement(declaration)` authors the element typed
+ * without being told.
+ */
+export declare const definePlugin: <A extends object>() => <const T extends Record<string, PluginTriggerSpec> = never, const C extends Record<string, PluginCallbackSpec> = never>({ type, label, description, attributes, triggers, callbacks, builder, market, bindable, style, definition, settings, ...rest }: PluginSpec<A, T, C>) => DefinedPlugin<A, T, C>;
 export {};

package/dist/authoring/declare.mjs

@@ -1,4 +1,97 @@
 //#region src/authoring/declare.ts
-var e = () => (e) => e, t = () => (e) => e;
+var e = () => (e) => e, t = () => ({
+	canDelete: !0,
+	canSelect: !0,
+	canDragDrop: !0,
+	canMove: !0,
+	canSnippet: !0,
+	itemsAllowed: [],
+	itemsNotAllowed: []
+}), n = (e, t) => ({
+	type: e,
+	bindings: {},
+	initialState: { visibility: !0 },
+	...t,
+	styleSelectors: {
+		base: "",
+		...t.styleSelectors
+	}
+}), r = () => (e) => {
+	let { definition: r, builder: i, market: a, defaultStyle: o, settings: s } = e.content;
+	return {
+		...e,
+		content: {
+			...e.content,
+			definition: n(e.type, r),
+			builder: {
+				...t(),
+				...i
+			},
+			market: {
+				owner: "Plitzi",
+				verified: !0,
+				license: "MIT",
+				website: "https://plitzi.com",
+				backgroundColor: "#4422ee",
+				...a
+			},
+			defaultStyle: {
+				name: r.label,
+				displayMode: "desktop",
+				...o
+			},
+			settings: s ?? {}
+		}
+	};
+}, i = (e) => e.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/^./, (e) => e.toUpperCase()), a = () => ({ type: e, label: r, description: a, attributes: o, triggers: s, callbacks: c, builder: l, market: u, bindable: d, style: f, definition: p, settings: m, ...h }) => {
+	let g = (e, t, n) => ({
+		action: t,
+		title: n.title ?? i(t),
+		type: e,
+		params: n.params ?? {},
+		...e === "trigger" ? { preview: n.preview ?? {} } : {}
+	}), _ = d ?? Object.keys(o);
+	return {
+		...h,
+		type: e,
+		triggers: Object.fromEntries(Object.entries(s ?? {}).map(([e, t]) => [e, g("trigger", e, t)])),
+		callbacks: Object.fromEntries(Object.entries(c ?? {}).map(([e, t]) => [e, g("callback", e, t)])),
+		content: {
+			attributes: o,
+			definition: n(e, {
+				label: r,
+				...a ? { description: a } : {},
+				items: [],
+				...p
+			}),
+			builder: {
+				...t(),
+				...l
+			},
+			market: {
+				category: r,
+				owner: "",
+				license: "MIT",
+				website: "",
+				backgroundColor: "#4422ee",
+				icon: "",
+				...u
+			},
+			defaultStyle: {
+				name: r,
+				displayMode: "desktop",
+				style: f ?? { base: { default: {} } },
+				bindingsAllowed: {
+					attributes: _.map((e) => ({
+						path: e,
+						label: i(e)
+					})),
+					initialState: []
+				}
+			},
+			settings: m ?? {}
+		}
+	};
+};
 //#endregion
-export { t as elementDeclaration, e as valuesOf };
+export { a as definePlugin, r as elementDeclaration, e as valuesOf };

package/dist/authoring/index.mjs

@@ -1,6 +1,6 @@
 import { toBuilderParams as e, toInteractionCallback as t, toInteractionCallbacks as n } from "./builder.mjs";
-import { elementDeclaration as r, valuesOf as i } from "./declare.mjs";
-import { BUILTIN_PARAM_TYPES as a, hiddenParams as o, invalidParams as s, missingRequiredParams as c, reconcileParams as l } from "./paramSpec.mjs";
-import { BUILTIN_ELEMENT_CALLBACKS as u, SCROLL_CALLBACKS as d, applyElementCallback as f, getElementCallback as p } from "./elementCallbacks.mjs";
-import { spaceCallbacks as m } from "./spaceCallbacks.mjs";
-export { u as BUILTIN_ELEMENT_CALLBACKS, a as BUILTIN_PARAM_TYPES, d as SCROLL_CALLBACKS, f as applyElementCallback, r as elementDeclaration, p as getElementCallback, o as hiddenParams, s as invalidParams, c as missingRequiredParams, l as reconcileParams, m as spaceCallbacks, e as toBuilderParams, t as toInteractionCallback, n as toInteractionCallbacks, i as valuesOf };
+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 };

package/dist/dataSource/getBindingsDetails.mjs

@@ -11,35 +11,35 @@ var c = (e, t, n, r, a) => {
 		fromValue: t ? i(e, t) : void 0,
 		toValue: i(n, o, t ? i(e, t) : void 0)
 	};
-}, l = (l, u, d = {}) => {
-	let { attributes: f, definition: p } = u, { bindings: m } = p;
-	return !m || typeof m == "object" && !Object.keys(m).length ? {
-		attributes: f,
+}, l = (e) => typeof e == "number" || typeof e == "string" && !/[;{}<>]/.test(e), u = (u, d, f = {}) => {
+	let { attributes: p, definition: m } = d, { bindings: h } = m;
+	return !h || typeof h == "object" && !Object.keys(h).length ? {
+		attributes: p,
 		style: {},
-		definition: p
+		definition: m
 	} : s({
-		attributes: f,
-		style: d,
-		definition: p
+		attributes: p,
+		style: f,
+		definition: m
 	}, (s) => {
-		Object.keys(m).forEach((u) => {
-			m[u] && Array.isArray(m[u]) && m[u].length && m[u].forEach((d) => {
-				let { source: f, transformers: p, when: m, enabled: h = !0 } = d, { to: g } = d;
-				if (!g || m && !o(m, l, !1, !0) || !h) return;
-				u === "style" && (g = r(g));
-				let { fromValue: _, toValue: v } = c(l, f, s, u, g), y = _;
-				p && Array.isArray(p) && p.length > 0 && p.forEach((e) => {
+		Object.keys(h).forEach((d) => {
+			h[d] && Array.isArray(h[d]) && h[d].length && h[d].forEach((f) => {
+				let { source: p, transformers: m, when: h, enabled: g = !0 } = f, { to: _ } = f;
+				if (!_ || h && !o(h, u, !1, !0) || !g) return;
+				d === "style" && !_.startsWith("--") && (_ = r(_));
+				let { fromValue: v, toValue: y } = c(u, p, s, d, _), b = v;
+				m && Array.isArray(m) && m.length > 0 && m.forEach((e) => {
 					let { action: r, params: i, enabled: a = !0 } = e;
 					if (!a) return;
 					let o = t[r];
-					o && (y = o.callback(y, n(o, i) ?? {}, s, {
-						...l,
-						sourceTo: v
+					o && (b = o.callback(b, n(o, i) ?? {}, s, {
+						...u,
+						sourceTo: y
 					}));
-				}), u === "initialState" && g === "visibility" && f && i(l, f) !== void 0 && (y = e(y)), (typeof y == "boolean" || typeof y == "number" || y) && (u === "initialState" ? a(s, `definition.${u}.${g}`, y) : a(s, `${u}.${g}`, y));
+				}), d === "initialState" && _ === "visibility" && p && i(u, p) !== void 0 && (b = e(b)), (d !== "style" || l(b)) && (typeof b == "boolean" || typeof b == "number" || b) && (d === "initialState" ? a(s, `definition.${d}.${_}`, b) : a(s, `${d}.${_}`, b));
 			});
 		});
 	});
 };
 //#endregion
-export { l as default };
+export { u as default };