@plitzi/plitzi-builder 0.37.8 → 0.37.9

package/CHANGELOG.md

@@ -1,5 +1,252 @@
 # @plitzi/plitzi-builder
 
+## 0.37.9
+
+### Patch Changes
+
+- 3ae61a4: ## Components replace segments
+
+  - **What a component is:** a reusable block written once and placed anywhere as an instance. An edit to the component
+    is an edit to every instance.
+  - **Where it lives:** in the space document, as `schema.components`, one tree per component and never in
+    `schema.flat`. It is published, rolled back, copied by templates and exported with the space.
+  - **Props and slots:**
+    - A component declares props (`type`, `description`, `required`, `default`, `options`). An instance hands them in
+      as its own attributes, so templates and bindings reach them. Inside, they are read as `{{ props.<name> }}`.
+    - Slots are elements an instance fills; each child names its slot in `attributes.slot`.
+  - **A prop an instance leaves out prints nothing.** It is its `default`, or `null`. `props` is a settled source:
+    - `processTwig` takes `{ settled }` in place of `keepEmptyTokens: true`.
+    - Every other empty token is still kept for a later pass.
+    - `COMPONENT_PROPS_SOURCE` names the source.
+  - **Fixed: a flow in a list row or a component instance acts on its own copy.** A step's target resolves in the
+    replica the flow fired in first, then outwards. It used to reach whichever copy registered last.
+  - **Fixed: an instance's own `visible` hides it in preview.** The same goes for an element reference.
+  - **Fixed: a list row keeps its state with its record.** Rows are keyed by each record's unique `id`, so filtering no
+    longer moves one row's state onto another.
+  - **Closed scope:** inside, a component reads only its props and the globals. The validator, `lintSpace` and
+    `authorSpace` each refuse a read of the page around an instance. Components nest, and a cycle is refused.
+  - **Where to use them:**
+    - In code (`@plitzi/sdk-authoring`): `SpaceSpec.components` and `component(id, { props, children })`.
+      `specFromSpace` and `specToSource` read and write both.
+    - In the builder:
+      - a Components panel lists them, and an open component becomes the canvas;
+      - an element becomes a component with **Save as component**;
+      - in an instance's settings, an instance gets its props and slots, or is **detached** back into a copy.
+    - In the MCP: `upsertComponent` and `deleteComponent`. Element ops work inside a component through `pageRef`.
+  - **Schema helpers:** `@plitzi/sdk-schema` gains `addComponent`, `updateComponent`, `removeComponent`,
+    `detachInstance`, `renameElement`, `treeOf`, `flatMapOf` and `documentIds`.
+  - **GraphQL and live events:** `SpaceAddComponent`, `SpaceUpdateComponent`, `SpaceRemoveComponent` and
+    `SpaceDetachInstance`, each with a live event. History records a declaration change as a `component` entry.
+  - **Breaking: segments are removed.** This covers:
+    - `@plitzi/sdk-shared`'s segment types, queries, mutations, context and `SEGMENT_*` events;
+    - `referenceType: 'segment'`;
+    - the `Segments` builder module;
+    - `Space.segments` and the `Segment`/`Segments` queries;
+    - `CommonState.prevSchema`.
+  - **Breaking: `ElementLayout` and `LayoutBody` change shape.**
+    - `ElementLayout` is `{ slots, rootId, type }`; it was `{ containerId }`.
+    - `LayoutBody` takes `bodies` keyed by slot.
+    - `reference`'s `referenceContainer` attribute is removed.
+  - Guide: `docs/en/components.md`.
+
+  ## Functions ask for the time they need
+  - **What changes:** a task can ask for more CPU or wall time than the default with `limits`, in milliseconds. Example:
+    `limits: { cpuMs: 1000, wallMs: 20_000 }`. `defineFunctions({ limits })` asks it for every task and route at once,
+    and a task's own limits win over those.
+  - **What a run is given:** what it asked for, or the default (100 ms of CPU, 10 s) when it asked for nothing. Never
+    above the space's plan or the deployment's ceiling.
+  - **Deployment ceilings:** `functions.limits` sets them. `DEFAULT_FUNCTION_CEILINGS` covers each unset one, at 2 s of
+    CPU and 30 s.
+  - **Asking for more than the ceiling** is a problem when the functions are saved; it is never quietly cut down.
+  - **Manifest:** carries what each task asked for, and the builder shows it beside the task.
+
+  ## Functions answer under `/fn`, not `/api`
+
+  A space's routes are served at `/fn/<path>` (`FUNCTION_ROUTES_PREFIX`). `/api` is a slug a site wants for a page of its
+  own. A page under `/fn` is refused instead (`page-route-reserved`).
+
+  ## The builder's Functions panel
+
+  Rebuilt around the code. The panel reads `defineFunctions` as it is typed and writes into it, so the code stays the one
+  place a function is declared.
+
+  - **Layout:** the tasks, routes and files on the left, the code in the middle, the selected task on the right.
+  - **Live list:** tasks and routes are listed as the code declares them, including tasks imported from another file.
+    A task you have written but not saved says so. Tasks built by calling something are counted, and listed once saved.
+  - **Code and panel follow each other:** clicking a task or a route opens its file at its line. Putting the cursor inside
+    a task's code selects that task.
+  - **New task:** + in Tasks asks for its namespace, action and title. The task is written into `defineFunctions` with a
+    `run` to start from, in the file's own quotes, and the editor opens on it.
+  - **Time limit:** each task gets a slider from 100 ms to 1 s of CPU per run, with presets. The value is written into
+    the task as `limits: { cpuMs }`. "Use default" takes it out. `DEFAULT_FUNCTION_TIME_LIMITS` in
+    `@plitzi/sdk-shared/actions` is the default both the panel and the server use.
+  - **Test:** fills a task's params the way its step does, from their defaults: a select, a switch or text. JSON stays a
+    toggle away. With unsaved changes, the button reads "Save & run": it saves, then runs. If the save fails, it says why.
+  - **Header:** shows Saved, Unsaved (and in how many files) or the number of problems the last save found. ⌘S saves.
+    **Discard** asks first, then puts every file back to what was last saved, or back to nothing for functions never
+    saved. Removing the functions is a quiet button beside Save.
+  - **Problems:** clicking one opens its file at its line.
+  - **Editor:** each file has its own editor and undo history. Opening another file no longer marks the one you left as
+    changed. Before this, it could also write the newly opened file's text into the one you left. The cause was in
+    `@plitzi/plitzi-ui`'s CodeMirror, fixed in 1.6.25, which every package now depends on. That release also sets code
+    editors (several lines) in a monospaced face again. Long lines scroll inside the editor, and the line numbers stay
+    in place.
+
+  ## A space's own functions are their own category of steps
+
+  In the action editor's step picker, the space's own functions are listed under **Functions**, apart from the
+  platform's **Tasks**. The other headings now read Callbacks, Global callbacks and Utilities. The saved step is still a
+  `task` node.
+
+  - `@plitzi/sdk-server`: every registered task has an `origin`, `'deployment'` (shipped with the server or a native
+    function) or `'space'` (from the space's functions). `describeCatalog`, `/_action/catalog` and the builder's
+    `SpaceActionTasks` carry it (`ActionTaskDescriptor.origin`).
+  - `@plitzi/sdk-shared`: an `InteractionCallback` may name the `group` the picker lists it under.
+
+  ## Fixed: preview no longer breaks a builder that is embedded in a page
+
+  When the builder is mounted inside a Plitzi page (the platform's `/spaces/:id/update`), going to preview with a page
+  that has SEO turned on left the builder unstyled. The previewed page wrote its title and description through a head
+  manager of the builder's own, and that manager rewrote the host page's head, removing the builder's own stylesheet.
+
+  - `@plitzi/sdk-shared`: a new render setting, `ownsHead`, says whether the page may write the document head. It is on
+    by default (`DEFAULT_RENDER_SETTINGS`).
+  - `@plitzi/sdk-elements`: `Page` writes its SEO only where `ownsHead` is on.
+  - Builder: sets `ownsHead: false` for its canvas. A page drawn there is in a frame, and the document head is the
+    editor's. The canvas's own `HelmetProvider` is gone.
+
+  ## Fixed: the builder's plan usage panel shows the space being edited
+  - **The 404 is gone.** Opening Plan usage said "The account breakdown could not be read (The server answered 404.)".
+    The panel asked `/account/usage`, which went away when accounts became workspaces.
+  - **Only this space.** The panel listed every space of the workspace. It now reads `/spaces/:spaceId/usage`, which
+    now also answers the space's own `pages` (the heaviest ten), `pagesTotal` and `periodEndsAt`. The plan's ceilings
+    stay on top. Anyone who can edit the space can read it, including a guest of another workspace.
+  - **It scrolls.** A long breakdown scrolls inside the modal, where it used to overflow.
+  - **`getKeyDecoded(webKey, true)` reads the token's subject.** The function, in `@plitzi/sdk-shared`, looked for
+    `data.spaceId`, which space tokens no longer carry, so every space decoded as 0. The builder asked about space 0, and
+    the builder and the SDK kept every space's persisted state under the same key on a host. Pages served without a
+    `webKey` (SSR) still decode as 0, which is what their painted-state cookie is named after.
+
+  ## Fixed: a remote plugin in the builder reads the canvas it sits in
+
+  The builder carries its own copy of the Plitzi runtime. A remote plugin imports `@plitzi/plitzi-sdk`, which the page's
+  import map resolves to the SDK's copy. Each copy made its own React contexts, so on the builder's canvas a plugin read
+  none of the canvas's providers. In the builder embedded in Plitzi's site, it read the site around the builder instead:
+  the site's element as its own, the site's live mode (so it stayed interactive while being edited), and the site's store
+  and interactions.
+
+  - `@plitzi/sdk-shared` gains `sharedContext(name, default)`: a context made once per page and handed to every copy of
+    the runtime that asks for it.
+  - The runtime's contexts now go through it, so a provider from any copy reaches a consumer from any copy:
+    - `@plitzi/sdk-shared`: service, component, schema, network, theme scope, dev tools, builder.
+    - `@plitzi/sdk-elements`: element, element parent, layout body.
+    - interactions, plugins, event bridge, auth, variables and style.
+  - The store's contexts need `@plitzi/nexus` 1.4.0, which does the same. Every `@plitzi/*` package now asks for
+    `^1.4.0`, which is published.
+
+  ## The source of plugins and runtimes is kept on the space
+
+  What a plugin or a runtime is built from now goes up with it, so a space can be taken back out as a project
+  (`plitzi create --from`, below).
+
+  - `@plitzi/cli`:
+    - `plitzi pack plugin` writes the plugin's source beside its zip: every file of the project its elements import,
+      `import type` included, and the packages they need. `--source-root` names the project those paths are relative to.
+    - `plitzi upload plugin` and `plitzi runtime push` keep that source on the space, in its private bucket.
+    - `plitzi pack source` writes it to a file.
+    - A source that cannot be kept (a file outside the project, an undeclared package, a credential in the code) never
+      stops the upload or the push: they say why, and the artifact is kept built only.
+  - `@plitzi/sdk-shared/source`: the snapshot's format, the paths it may hold and the credential check, shared by the CLI
+    and the platform.
+
+  ## `plitzi create --from` and `plitzi pull`: a space on Plitzi as a project of your own
+
+  The way back from everything the CLI puts on Plitzi. `plitzi create my-board --from pizarra` writes a server project
+  holding what the space is made of, and runs it with nothing of Plitzi's: neither its servers nor its CDN. `plitzi pull`
+  keeps it in step with the space. See `docs/en/projects-from-spaces.md`.
+
+  - **What lands in the project:**
+    - its pages as authoring code;
+    - its server actions as `defineAction` code — JSON, with the reason said, for one that would not read back exactly;
+    - its plugins and runtime as the source they were uploaded from, and its functions;
+    - its files, downloaded into `public/`, with every CDN address rewritten to the project's.
+  - **`src/main.ts`** serves all of it, the runtime in the same process.
+  - **`.env`** gets a key made for the project's actions to sign with, and the names of the variables and credentials
+    the space had. Their values stay on Plitzi.
+  - **Who may run it:** the person must be signed in and able to change the space (owner, administrator or writer).
+  - **Plugins** are rebuilt against the project's SDK. One uploaded before sources were kept runs as it was built, from
+    `vendor/plugins/`, and the report says to upload it again.
+  - **The end of `create`** says what came across differently, including a space whose visitors sign in with Plitzi.
+  - `--source cloud` keeps the pages on Plitzi and runs the rest locally.
+  - **Any version:** `--environment` and `--revision` take out a published snapshot — its latest, or one revision pinned
+    — instead of the draft, with the source its plugins and runtime were built from then. A cloud project serves that
+    revision pinned.
+  - **`plitzi pull`** writes what changed on the space, keeps what changed in the project, and writes nothing when a
+    file changed on both — naming them, with `--force` to take the space's copy. It never touches `.env`, only adds to
+    `package.json`, and keeps `plitzi functions push` working from the project. It follows the version the project was
+    made from, and `--environment`/`--revision` move it.
+  - `@plitzi/sdk-authoring`:
+    - `actionSpecFromEntry` reads an action document back into its `defineAction` declaration, only when the round trip
+      is exact, and `actionToSource` writes it as a module.
+    - `defineAction` takes `limits`.
+    - `specToSource` takes `importExtension: '.ts'`, for split files that Node imports as they are.
+
+  ## The builder shows what a snapshot holds
+
+  **Make Snapshot** lists what it will freeze — pages, layouts and elements, server actions, connectors, functions, the
+  runtime and the plugins, each with whether its source is kept — and what no snapshot freezes: the space's files, its
+  variables and credentials. A space's components are part of its document, so they are frozen with its pages. **Publish Snapshot** lists what the chosen environment's snapshot holds.
+
+  ## Fixed: a space read from Plitzi kept its server elements
+  - **What happened:** a page server reading its space from Plitzi (`createCloudAdapters`) never ran an element's
+    `render` action, and a browser-rendered space ignored `loadStrategy`. The space's GraphQL answered neither
+    `runtime` nor `loadStrategy` of an element, nor the space's `rsc` settings.
+  - **Now:** the platform answers them, and the SDK, the builder and the cloud adapters ask for them.
+
+  ## A plugin the deployment registers is not looked for elsewhere
+
+  `@plitzi/sdk-server` used to fetch the manifest of every plugin the space lists on its CDN, even one the deployment
+  registers itself, and logged a warning when the CDN was out of reach. It now asks only for the ones it does not have.
+
+  ## Fixed: inline code in Markdown carries nothing of the syntax tree
+
+  A `markdown` element wrote every inline `` `code` `` as `<code node="[object Object]">`: `react-markdown` hands its
+  renderers the syntax-tree node as a prop, and the inline branch spread it onto the tag. Fixed in
+  `@plitzi/plitzi-ui` 1.6.26 (with a test), which every package now asks for.
+
+  ## Dev tools hear about the render run the page stopped waiting for
+
+  When a server element's action ran past the section's budget, the page was answered without it. The run ended a moment
+  later, after the page's runs had been sent, so the dev tools never showed the one run that needed debugging. It is now
+  told the moment the page stops waiting, as `aborted`, with the reason.
+
+  ## Fixed: a tab you come back to no longer loses its session
+  - **What happened:** a page left in another tab past its access token's life signed its visitor out on return. A
+    reload put them right back in.
+  - **Why:** the browser drops the cookie carrying the access token the moment the token expires, and the background
+    tab's renewal timer had not run. The first check on return was told `missing`, which the client took as no
+    session at all.
+  - **Now:** a `missing` refusal is renewed instead whenever the browser can still renew, meaning it holds a refresh
+    token or a session hint whose renewal window is open. The session ends only if that renewal fails.
+  - **Requests made in that moment:** `reportAuthFailure` now answers whether it renewed the session. A read refused
+    as the tab came back is asked again, once, once the session is renewed. This covers an api container's read and a
+    server section's refresh, so they no longer show a 401 that only a reload cleared.
+
+- Updated dependencies [3ae61a4]
+  - @plitzi/sdk-auth@0.37.9
+  - @plitzi/sdk-authoring@0.37.9
+  - @plitzi/sdk-dev-tools@0.37.9
+  - @plitzi/sdk-elements@0.37.9
+  - @plitzi/sdk-event-bridge@0.37.9
+  - @plitzi/sdk-interactions@0.37.9
+  - @plitzi/sdk-navigation@0.37.9
+  - @plitzi/sdk-plugins@0.37.9
+  - @plitzi/sdk-schema@0.37.9
+  - @plitzi/sdk-shared@0.37.9
+  - @plitzi/sdk-style@0.37.9
+  - @plitzi/sdk-variables@0.37.9
+  - @plitzi/plitzi-sdk@0.37.9
+
 ## 0.37.8
 
 ### Patch Changes

package/dist/index.html

@@ -56,10 +56,10 @@
       render(
         'plitzi',
         {
-          webKey: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxIiwib3JpZ2lucyI6WyJodHRwczovL3dlYnNpdGUucGxpdHppLmFwcCIsImh0dHBzOi8vcGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsOjMwMDAiLCJodHRwczovL2FwcC5wbGl0emkubG9jYWw6MzAwMSIsImh0dHBzOi8vc3NyLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vc2VydmVyLnBsaXR6aS5sb2NhbCIsImh0dHA6Ly9sb2NhbGhvc3Q6MzAwMCIsImh0dHA6Ly9sb2NhbGhvc3Q6ODA4MCIsImh0dHA6Ly8xMjcuMC4wLjE6ODA4MCIsImh0dHBzOi8vZGV2LnBsaXR6aS5jb20iLCJodHRwczovL3BsaXR6aS5jb20iLCJodHRwczovL3N0Zy5wbGl0emkuY29tIl0sImlzcyI6Imh0dHBzOi8vc2VydmVyLnBsaXR6aS5sb2NhbCIsImF1ZCI6WyJodHRwczovL3BsaXR6aS5sb2NhbCIsImh0dHBzOi8vYXBwLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vYXBwLnBsaXR6aS5sb2NhbDozMDAwIiwiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsOjMwMDEiLCJodHRwczovL2FwaS5wbGl0emkubG9jYWwiLCJodHRwczovL3Nzci5wbGl0emkubG9jYWwiLCJodHRwczovL3NlcnZlci5wbGl0emkubG9jYWwiLCJodHRwczovL21jcC5wbGl0emkubG9jYWwiLCJodHRwczovL2F1dGgucGxpdHppLmxvY2FsIiwiaHR0cDovLzEyNy4wLjAuMTo1MzAwIiwiaHR0cDovL2xvY2FsaG9zdDo1MTgwIl0sInNjb3BlIjoic3BhY2U6cmVuZGVyIiwiaWF0IjoxNzkwMjEzMjg5LCJqdGkiOiJhZDgyN2EyMjliZjhlMzk3IiwibmJmIjoxNzkwMjEzMjg5fQ.dedpVVA5Nv3Xr7nEOZ8UmEJcIamF9AHGnLgqQyDV8-k',
+          webKey: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxOCIsIm9yaWdpbnMiOlsiaHR0cHM6Ly90cmVtb3IucGxpdHppLmFwcCIsImh0dHBzOi8vdHJlbW9yLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vcGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsOjMwMDAiLCJodHRwczovL2FwcC5wbGl0emkubG9jYWw6MzAwMSIsImh0dHBzOi8vc3NyLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vc2VydmVyLnBsaXR6aS5sb2NhbCIsImh0dHA6Ly9sb2NhbGhvc3Q6MzAwMCIsImh0dHA6Ly9sb2NhbGhvc3Q6ODA4MCIsImh0dHA6Ly8xMjcuMC4wLjE6ODA4MCJdLCJpc3MiOiJodHRwczovL3NlcnZlci5wbGl0emkubG9jYWwiLCJhdWQiOlsiaHR0cHM6Ly9wbGl0emkubG9jYWwiLCJodHRwczovL2FwcC5wbGl0emkubG9jYWwiLCJodHRwczovL2FwcC5wbGl0emkubG9jYWw6MzAwMCIsImh0dHBzOi8vYXBwLnBsaXR6aS5sb2NhbDozMDAxIiwiaHR0cHM6Ly9hcGkucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9zc3IucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9zZXJ2ZXIucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9tY3AucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hdXRoLnBsaXR6aS5sb2NhbCIsImh0dHA6Ly8xMjcuMC4wLjE6NTMwMCIsImh0dHA6Ly9sb2NhbGhvc3Q6NTE4MCJdLCJzY29wZSI6InNwYWNlOnJlbmRlciIsImlhdCI6MTc5MDc5NDEyMywianRpIjoiNmU1MTNmOTIwNTEwMzNkNCIsIm5iZiI6MTc5MDc5NDEyM30.4zBNY-E9PJZUfotar7D9LDM5yuwHOQc1nbxhHLPbVgA',
           // The actor. Without it the builder loads and every write is refused, since authorization is
           // can(actor, space, permission). Both halves come from `yarn token 1 --user admin` in plitzi-sdk-server.
-          userKey: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxIiwiaXNzIjoiaHR0cHM6Ly9zZXJ2ZXIucGxpdHppLmxvY2FsIiwiYXVkIjpbImh0dHBzOi8vcGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsOjMwMDAiLCJodHRwczovL2FwcC5wbGl0emkubG9jYWw6MzAwMSIsImh0dHBzOi8vYXBpLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vc3NyLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vc2VydmVyLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vbWNwLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vYXV0aC5wbGl0emkubG9jYWwiLCJodHRwOi8vMTI3LjAuMC4xOjUzMDAiLCJodHRwOi8vbG9jYWxob3N0OjUxODAiXSwic2NvcGUiOiJ1c2VyIiwiZXhwIjoxNzkwMjg3MDg0LCJpYXQiOjE3OTAyMDA2ODQsImp0aSI6ImNiZWE3MDZlNzYyZGFiNGUiLCJuYmYiOjE3OTAyMDA2ODR9.IpPxIRFRi6KXz0yCC1fPQF6hLubU_7u0fTcgQohmB10',
+          userKey: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxIiwiaXNzIjoiaHR0cHM6Ly9zZXJ2ZXIucGxpdHppLmxvY2FsIiwiYXVkIjpbImh0dHBzOi8vcGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsIiwiaHR0cHM6Ly9hcHAucGxpdHppLmxvY2FsOjMwMDAiLCJodHRwczovL2FwcC5wbGl0emkubG9jYWw6MzAwMSIsImh0dHBzOi8vYXBpLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vc3NyLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vc2VydmVyLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vbWNwLnBsaXR6aS5sb2NhbCIsImh0dHBzOi8vYXV0aC5wbGl0emkubG9jYWwiLCJodHRwOi8vMTI3LjAuMC4xOjUzMDAiLCJodHRwOi8vbG9jYWxob3N0OjUxODAiXSwic2NvcGUiOiJ1c2VyIiwiZXhwIjoxNzkwODgwNDk3LCJpYXQiOjE3OTA3OTQwOTcsImp0aSI6IjgzNWVjMTA5MDhkNzA4NjYiLCJuYmYiOjE3OTA3OTQwOTd9.aSm7PJz1yPtXjPD9DT40IWaqK7N9EAuSZ1Bsb7ZvABc',
           environment: 'main',
           functionsWorkerUrl: '/plitzi-functions-worker.js',
           server: {

package/dist/modules/App/components/AppHeader/QuotaBreakdown.d.ts

@@ -6,14 +6,15 @@ export type QuotaBreakdownProps = {
     liveElements: number;
 };
 /**
- * The number in the header, taken apart.
+ * The number in the header, taken apart — for the space being edited.
  *
- * The meter answers "how much room is left"; this answers what follows it — where the room went. Two breakdowns,
- * because the two ceilings are spent by different things: elements sit in pages, and page views are spent by
- * visitors on paths.
+ * The meter answers "how much room is left"; this answers what follows it — where this space's room went. Two
+ * breakdowns, because the two ceilings are spent by different things: elements sit in pages, and page views are spent by
+ * visitors on paths. The account's ceilings stay at the top, since the space spends them too; how the workspace's other
+ * spaces spent them is the dashboard's to show, to its members.
  *
- * The space being edited is answered entirely from the store, so it is on screen before any request is made, and it
- * is there even for someone whose account owns none of this. The rest of the account is what the request is for.
+ * Its elements are answered from the store, so they are on screen before any request is made. Its page views are what
+ * the request is for. Scrolls on its own: a space with many pages is longer than the window.
  */
 declare const QuotaBreakdown: ({ readings, spaceId, liveElements }: QuotaBreakdownProps) => import('react').JSX.Element;
 export default QuotaBreakdown;

package/dist/modules/App/components/VersionContents/PluginList.d.ts

@@ -0,0 +1,7 @@
+import { SpaceVersionContents } from '@plitzi/sdk-shared';
+export type PluginListProps = {
+    plugins: SpaceVersionContents['plugins'];
+};
+/** Each installed plugin, and whether it can be taken out as code or only as it was built. */
+declare const PluginList: ({ plugins }: PluginListProps) => import('react').JSX.Element;
+export default PluginList;

package/dist/modules/App/components/VersionContents/VersionContents.d.ts

@@ -0,0 +1,14 @@
+import { Environment } from '@plitzi/sdk-shared';
+export type VersionContentsProps = {
+    environment: Environment;
+    /** A snapshot's revision; an environment's latest when left out. Meaningless for the draft. */
+    revision?: number;
+    /** What the list is: "This snapshot will freeze", "production r3 holds". */
+    title: string;
+};
+/**
+ * What one version of the space holds — the draft a snapshot would freeze, or a snapshot as it was frozen — and what no
+ * version holds, because every version shares it. Read from the platform, which is what freezes it.
+ */
+declare const VersionContents: ({ environment, revision, title }: VersionContentsProps) => import('react').JSX.Element;
+export default VersionContents;

package/dist/modules/App/components/VersionContents/helpers.d.ts

@@ -0,0 +1,8 @@
+import { SpaceVersionContents } from '@plitzi/sdk-shared';
+/** One line of what a version holds: what it is, and how much of it. */
+export type ContentsRow = {
+    label: string;
+    value: string;
+};
+/** What a version holds, as the lines the builder shows — the plugins are listed on their own, by name. */
+export declare const contentsRows: (contents: SpaceVersionContents) => ContentsRow[];

package/dist/modules/App/components/VersionContents/helpers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/App/components/VersionContents/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './VersionContents';
+export type { VersionContentsProps } from './VersionContents';

package/dist/modules/App/components/VersionContents/useVersionContents.d.ts

@@ -0,0 +1,8 @@
+import { Environment, SpaceVersionContents } from '@plitzi/sdk-shared';
+/** What one version of the space holds: the draft, or an environment's snapshot — its latest unless one is named. */
+declare const useVersionContents: (environment: Environment, revision?: number) => {
+    contents: SpaceVersionContents | undefined;
+    loading: boolean;
+    error: Error | undefined;
+};
+export default useVersionContents;

package/dist/modules/Builder/BuilderProvider.d.ts

@@ -2,7 +2,7 @@ import { EventBridgeEvent } from '@plitzi/sdk-shared';
 export type BuilderProviderProps = {
     children: React.ReactNode;
     baseElementId: string;
-    mode?: 'normal' | 'template' | 'segment';
+    mode?: 'normal' | 'template';
     schemaName?: string;
     onHandler?: (event: EventBridgeEvent, data: unknown[]) => void;
     onBaseElementChange?: (baseElementId: string) => void;

package/dist/modules/Components/Components.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The space's components: what each is called and how many places render it. A component is placed by dragging it
+ * onto a page, and edited by opening it in the canvas, where its tree is edited like a page's.
+ */
+declare const Components: () => import('react').JSX.Element;
+export default Components;

package/dist/modules/Components/components/ComponentBanner/ComponentBanner.d.ts

@@ -0,0 +1,7 @@
+import { SpaceComponent } from '@plitzi/sdk-shared';
+export type ComponentBannerProps = {
+    component: SpaceComponent;
+};
+/** Says the canvas is a component, not a page — every instance of it changes with what is edited here. */
+declare const ComponentBanner: ({ component }: ComponentBannerProps) => import('react').JSX.Element;
+export default ComponentBanner;

package/dist/modules/Components/components/ComponentBanner/index.d.ts

@@ -0,0 +1 @@
+export { default } from './ComponentBanner';

package/dist/modules/Components/components/ComponentForm/ComponentForm.d.ts

@@ -0,0 +1,19 @@
+import { PageFolder, SpaceComponentDeclaration } from '@plitzi/sdk-shared';
+import { MouseEvent } from 'react';
+export type ComponentFormProps = {
+    declaration?: SpaceComponentDeclaration;
+    /** The elements of the component's tree that can be a slot: those that hold children. */
+    slotChoices?: {
+        id: string;
+        label: string;
+    }[];
+    pageFolders?: PageFolder[];
+    onClose?: (e?: MouseEvent) => void;
+    onSubmit?: (e: MouseEvent | undefined, values: SpaceComponentDeclaration) => void;
+};
+/**
+ * What a component declares: what it is called, where the builder files it, the props an instance hands in and the
+ * elements of its tree an instance fills.
+ */
+declare const ComponentForm: ({ declaration, slotChoices, pageFolders, onClose, onSubmit }: ComponentFormProps) => import('react').JSX.Element;
+export default ComponentForm;

package/dist/modules/Components/components/ComponentForm/SlotChoice.d.ts

@@ -0,0 +1,8 @@
+export type SlotChoiceProps = {
+    id: string;
+    label: string;
+    checked: boolean;
+    onToggle: (id: string, checked: boolean) => void;
+};
+declare const SlotChoice: ({ id, label, checked, onToggle }: SlotChoiceProps) => import('react').JSX.Element;
+export default SlotChoice;

package/dist/modules/Components/components/ComponentForm/index.d.ts

@@ -0,0 +1 @@
+export { default } from './ComponentForm';

package/dist/modules/Components/components/ComponentItem/ComponentItem.d.ts

@@ -0,0 +1,12 @@
+import { PageFolder, SpaceComponent } from '@plitzi/sdk-shared';
+export type ComponentItemProps = {
+    component: SpaceComponent;
+    /** How many places in the space render it. */
+    instances: number;
+    /** Whether it is the one open in the canvas. */
+    open: boolean;
+    pageFolders: PageFolder[];
+};
+/** One component of the space: dragged onto a page to place it, opened to edit its tree, renamed, removed. */
+declare const ComponentItem: ({ component, instances, open, pageFolders }: ComponentItemProps) => import('react').JSX.Element;
+export default ComponentItem;

package/dist/modules/Components/components/ComponentItem/index.d.ts

@@ -0,0 +1 @@
+export { default } from './ComponentItem';

package/dist/modules/Components/components/InstanceTools/InstanceTools.d.ts

@@ -0,0 +1,10 @@
+export type InstanceToolsProps = {
+    instanceId: string;
+    componentId: string;
+};
+/**
+ * What only the builder can do with an instance, beside the settings of the element itself: open the component it
+ * places, put each of its children in a slot, and detach it — a copy of the component that is then this page's own.
+ */
+declare const InstanceTools: ({ instanceId, componentId }: InstanceToolsProps) => import('react').JSX.Element | null;
+export default InstanceTools;

package/dist/modules/Components/components/InstanceTools/SlotRow.d.ts

@@ -0,0 +1,13 @@
+import { Element } from '@plitzi/sdk-shared';
+export type SlotRowProps = {
+    child: Element;
+    slots: {
+        value: string;
+        label: string;
+    }[];
+    /** The slot a child naming none goes in: the component's first. */
+    fallback?: string;
+};
+/** One child of an instance, and the slot of the component it fills. */
+declare const SlotRow: ({ child, slots, fallback }: SlotRowProps) => import('react').JSX.Element;
+export default SlotRow;

package/dist/modules/Components/components/InstanceTools/index.d.ts

@@ -0,0 +1 @@
+export { default } from './InstanceTools';

package/dist/modules/Components/components/PropsEditor/PropRow.d.ts

@@ -0,0 +1,14 @@
+import { ComponentProp } from '@plitzi/sdk-shared';
+export type PropEntry = {
+    name: string;
+    prop: ComponentProp;
+};
+export type PropRowProps = {
+    index: number;
+    entry: PropEntry;
+    problem?: string;
+    onChange: (index: number, entry: PropEntry) => void;
+    onRemove: (index: number) => void;
+};
+declare const PropRow: ({ index, entry, problem, onChange, onRemove }: PropRowProps) => import('react').JSX.Element;
+export default PropRow;

package/dist/modules/Components/components/PropsEditor/PropsEditor.d.ts

@@ -0,0 +1,11 @@
+import { PropEntry } from './PropRow';
+export type PropsEditorProps = {
+    value: PropEntry[];
+    onChange: (value: PropEntry[]) => void;
+};
+/**
+ * The props a component declares, one row each: the name it is read by (`{{ props.<name> }}`), its kind, what it is
+ * for and whether an instance must hand it in.
+ */
+declare const PropsEditor: ({ value, onChange }: PropsEditorProps) => import('react').JSX.Element;
+export default PropsEditor;

package/dist/modules/Components/components/PropsEditor/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './PropsEditor';
+export type { PropEntry } from './PropRow';

package/dist/modules/Components/helpers.d.ts

@@ -0,0 +1,17 @@
+import { ComponentDefinition, Schema, SpaceComponent } from '@plitzi/sdk-shared';
+/** A name for a new component, from what the author called it and free among the space's components. */
+export declare const componentIdFor: (label: string, components: Schema["components"]) => string;
+/**
+ * A new component with nothing in it yet: the one container it is built in, made the way a drop makes one — from the
+ * element's own declaration — and named free of every tree of the document.
+ */
+export declare const emptyComponent: (label: string, schema: Pick<Schema, "flat" | "components">, container: ComponentDefinition) => SpaceComponent;
+/** What the builder shows a component as: the name the author gave it, else its id. */
+export declare const componentLabel: (component: SpaceComponent) => string;
+/**
+ * How many places render each component.
+ *
+ * Counted tree by tree. While a component is open, the builder reads `schema.flat` with its tree laid over the pages',
+ * so an element is counted from that flat only when no component holds it — and from its component's tree otherwise.
+ */
+export declare const instanceCounts: (schema: Pick<Schema, "flat" | "components">) => Record<string, number>;

package/dist/modules/Components/helpers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/Components/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './Components';
+export { default as useOpenComponent } from './useOpenComponent';

package/dist/modules/Components/slotChoices.d.ts

@@ -0,0 +1,9 @@
+import { ComponentDefinition, Element, Schema } from '@plitzi/sdk-shared';
+/**
+ * The elements of a tree hung off `rootId` that can be a slot: those whose TYPE holds children, as its declaration
+ * says. Not the element's own `items`, which an authored document gives every element, a text included.
+ */
+export declare const slotChoicesOf: (flat: Schema["flat"], rootId: Element["id"], definitions: Record<string, ComponentDefinition>) => {
+    id: string;
+    label: string;
+}[];

package/dist/modules/Components/useOpenComponent.d.ts

@@ -0,0 +1,13 @@
+import { SpaceComponent } from '@plitzi/sdk-shared';
+/**
+ * The component open in the canvas, and the scope the builder is drawn in while it is.
+ *
+ * The scope lays the component's tree over the pages' — ids are one namespace, so every tool that finds an element by
+ * id finds the component's — and hands its props their defaults. With nothing open it is empty, and a scope with
+ * nothing of its own reads straight through to the store.
+ */
+declare const useOpenComponent: () => {
+    component?: SpaceComponent;
+    scope: Record<string, unknown>;
+};
+export default useOpenComponent;

package/dist/modules/Components/useSaveAsComponent.d.ts

@@ -0,0 +1,7 @@
+import { Element } from '@plitzi/sdk-shared';
+/**
+ * Makes a component of an element on the canvas: the element and everything inside it become the component's tree,
+ * and an instance of it takes the element's place, so the page renders what it did. Returns whether it was made.
+ */
+declare const useSaveAsComponent: () => (element: Element) => Promise<boolean>;
+export default useSaveAsComponent;

package/dist/modules/Elements/ElementHelper.d.ts

@@ -4,8 +4,9 @@ import { ComponentDefinition, Element, Schema } from '@plitzi/sdk-shared';
  *  A drop can insert a whole sub-tree at once, and each element of it needs a name that is free of the document AND
  *  of its siblings in the same drop — which is why the taken set is carried across the burst rather than re-read
  *  per element. The random minter, not the positional one: the builder and the MCP write the same document
- *  concurrently, and a counter has both mint `heading-3`. */
-export declare const makeIdMinter: (flat: Schema["flat"]) => (type: string) => string;
+ *  concurrently, and a counter has both mint `heading-3`. Free of every tree — the pages' and each component's — since
+ *  ids are one namespace across them. */
+export declare const makeIdMinter: (schema: Pick<Schema, "flat" | "components">) => (type: string) => string;
 export declare const getInitialItems: (parentId: string, items: string[] | undefined, definitions: Record<string, ComponentDefinition>, mintId: (type: string) => string, rootId?: string) => {
     directItems: Record<string, Element>;
     items: Record<string, Element>;

package/dist/modules/Elements/hooks/useDragElement.d.ts

@@ -5,9 +5,10 @@ export type UseDragElementProps = {
     type: string;
     variables?: object[];
     manifest?: Template;
-    onParentRefresh?: (identifier: string, segment: object) => void;
+    /** What the dropped element is called in the builder's tree, instead of its type's default label. */
+    label?: string;
 };
-declare const useDragElement: ({ attributes, type, variables, manifest }: UseDragElementProps) => {
+declare const useDragElement: ({ attributes, type, variables, manifest, label }: UseDragElementProps) => {
     onDragStart: (e: DragEvent) => void;
 };
 export default useDragElement;

package/dist/modules/Functions/Functions.d.ts

@@ -1,7 +1,8 @@
 /**
- * The space's own server code: its files, edited with TypeScript that knows the contract, saved as the draft
- * — built and checked on the platform, problems shown where they are — and tried in the sandbox. The live site runs
- * what the space was last published with. A project's `plitzi functions pull` edits the same files.
+ * The space's own server code: its tasks and routes as the code declares them — listed as it is typed — its files,
+ * edited with TypeScript that knows the contract, and the selected task's time limit and test run beside them. Saved as
+ * the draft, built and checked on the platform; the live site runs what the space was last published with. A
+ * project's `plitzi functions pull` edits the same files.
  */
 declare const Functions: () => import('react').JSX.Element;
 export default Functions;

package/dist/modules/Functions/components/FunctionInspector/FunctionInspector.d.ts

@@ -0,0 +1,20 @@
+import { ListedTask } from '../../helpers';
+import { ActionRunReport, FunctionTimeLimits } from '@plitzi/sdk-shared';
+export type FunctionInspectorProps = {
+    task: ListedTask;
+    /** What every task gets unless it asks for its own, from `defineFunctions`. */
+    sharedLimits?: FunctionTimeLimits;
+    hosts: string[];
+    /** Why its limits cannot be written for you right now — the code is still being read, say — or nothing. */
+    limitsDisabledReason: string;
+    /** The code differs from the saved draft. */
+    modified: boolean;
+    onLimitsChange: (task: ListedTask, cpuMs: number | undefined) => void;
+    onRun: (task: string, params: Record<string, unknown>) => Promise<ActionRunReport | undefined>;
+};
+/**
+ * The selected task: what it is as a step, how much CPU a run of it may use — written into its code — and a run of it
+ * in the sandbox, saving first when the code changed.
+ */
+declare const FunctionInspector: ({ task, sharedLimits, hosts, limitsDisabledReason, modified, onLimitsChange, onRun }: FunctionInspectorProps) => import('react').JSX.Element;
+export default FunctionInspector;