npm - @plitzi/sdk-shared - Versions diffs - 0.33.2 → 0.34.1 - Mend

@plitzi/sdk-shared 0.33.2 → 0.34.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (204) hide show

package/dist/types/ActionTypes.d.ts ADDED Viewed

@@ -0,0 +1,396 @@
+import { Environment } from './CommonTypes';
+import { ElementInteraction } from './SchemaTypes';
+/**
+ * What an action's inputs and outputs may be.
+ *
+ * Deliberately NOT `CollectionField['type']`: that vocabulary describes CMS content (`richText`, `multiImage`,
+ * `video`) and an action takes arguments, not entries. `json` is the escape hatch for a nested payload, and it is
+ * the only one whose contents are not validated beyond being parseable.
+ */
+export type ActionFieldType = 'text' | 'number' | 'boolean' | 'date' | 'json' | 'file';
+export type ActionField = {
+    type: ActionFieldType;
+    required?: boolean;
+    defaultValue?: string | number | boolean;
+    /** Shown in the builder, and read by the MCP agent when it wires a call. */
+    label?: string;
+};
+/**
+ * Who may start a run through ONE way in. Resolved against the auth kernel — never re-implemented here.
+ *
+ * It belongs to the trigger and not to the action, because the two are different questions: a webhook is reachable
+ * by anyone who learns its URL and is gated on its signature, while the same flow called from a page may well
+ * require a session. Stating it once for the action forced the loosest of its ways in onto all of them.
+ *
+ * There is no implicit default: a trigger that declares no access is refused at save time rather than falling back
+ * to something a reader has to guess at.
+ */
+export type ActionAccess =
+/** Anyone, including an anonymous visitor. Implicit for a webhook; anywhere else it is a deliberate choice. */
+{
+    mode: 'public';
+}
+/** Any request carrying a valid session for this space. */
+ | {
+    mode: 'session';
+}
+/** A session holding every one of these space permissions. */
+ | {
+    mode: 'role';
+    permissions: string[];
+};
+/**
+ * How an inbound webhook proves it is who it claims to be. Verified against the RAW body, before parsing and before
+ * the run starts — a public endpoint with no verification is a warning at save time and in the logs.
+ */
+export type ActionWebhookVerification = {
+    type: 'hmac';
+    /** Header carrying the signature, e.g. `stripe-signature`. */
+    header: string;
+    algorithm: 'sha256' | 'sha1';
+    /** The credential holding the signing secret. Named outright rather than templated: this runs before anything
+     *  else does, and a token that renders to nothing here is an endpoint that verifies against an empty secret. */
+    credential: string;
+    /** Which key of that credential is the secret. Defaults to `secret`. */
+    secretField?: string;
+    /**
+     * Header carrying the moment the sender signed, when it sends one separately (the Stripe shape). The signed
+     * payload is then `<timestamp>.<body>` rather than the body alone.
+     *
+     * Without it `toleranceSeconds` has nothing to compare against: a signature over the body alone is valid
+     * forever, so a captured request can be replayed until the secret rotates.
+     */
+    timestampHeader?: string;
+    /** Rejects a signature older than this many seconds. Needs `timestampHeader`. */
+    toleranceSeconds?: number;
+};
+/**
+ * The ways into an action, as the `action` of a trigger STEP rather than a list beside the flow.
+ *
+ * `call` — a client flow through the action endpoint. `webhook` — an inbound request, public by construction.
+ * `schedule` — a cron tick. `render` — a `runtime: 'server'` element naming this action. `custom` — a trigger the
+ * deployment mounted itself.
+ */
+export type ActionTriggerType = 'call' | 'webhook' | 'schedule' | 'render' | 'custom';
+/**
+ * What a trigger step carries, in its `params`.
+ *
+ * FLAT and stringy, because that is what a step's params are everywhere in this product: the flow editor renders
+ * `text`, `select` and `codemirror-json` controls over primitives, and a trigger authored anywhere else would be a
+ * second editor to build and to keep in step. So the two contracts an action has are both JSON on a step — `input`
+ * here, and the output step's `values` at the other end.
+ *
+ * Read it with the helpers in `@plitzi/sdk-shared/actions` rather than by hand: they are what the validator and
+ * the runner share, so what the editor accepts is exactly what the runner will do.
+ */
+export type ActionTriggerParams = {
+    /** Who may start a run this way. Required for every kind but `schedule`, which has no caller. */
+    access?: ActionAccess['mode'];
+    /** Comma-separated, and only meaningful for `access: 'role'`. */
+    permissions?: string;
+    /** JSON map of {@link ActionField} by name: what a caller may send THIS way. Undeclared keys are dropped. */
+    input?: string;
+    /**
+     * `webhook`: the credential holding the signing secret.
+     *
+     * **Naming one is what turns verification on**, and it is the only field that has to be set — everything below
+     * has a default that works. That is deliberate: a half-filled verification is an endpoint that looks protected
+     * and is not, so the shape does not allow one. Absent means an endpoint anyone who learns the URL can start,
+     * which the validator warns about.
+     */
+    signatureCredential?: string;
+    /** Header the signature arrives in. Defaults to `x-signature`; a provider that uses its own says so here. */
+    signatureHeader?: string;
+    /** `sha256` (the default) or `sha1`. */
+    signatureAlgorithm?: string;
+    /** Which key of the credential holds the secret. Defaults to `secret`. */
+    signatureSecretField?: string;
+    /**
+     * Header carrying the moment the sender signed, when it sends one separately (the Stripe shape). The signed
+     * payload is then `<timestamp>.<body>` rather than the body alone.
+     */
+    signatureTimestampHeader?: string;
+    /** Rejects a signature older than this many seconds. Means nothing without the timestamp header. */
+    signatureToleranceSeconds?: string;
+    /**
+     * `render`: how long an answer may be reused, in seconds. Absent or `0` means every render runs the flow.
+     *
+     * It belongs to the trigger for the same reason access does: it is a property of THIS way in. A call is
+     * somebody asking for something to happen and must not be served from a cache; a render is a read repeated
+     * once per visitor, and the difference between one outbound request and ten thousand of them is this number.
+     *
+     * Renders that arrive while one is already in flight are answered by it whatever this says — that is not a
+     * cache, it is the same run being shared, and it can never serve an answer older than the request.
+     */
+    cacheSeconds?: string;
+    /** `schedule`: five fields — minute hour day-of-month month day-of-week. UTC. */
+    cron?: string;
+    timezone?: string;
+    /** `custom`: the name the deployment mounts it under. */
+    name?: string;
+};
+/** Ceilings for one run. A per-action value may only tighten the deployment's own. */
+export type ActionLimits = {
+    timeoutMs?: number;
+    /** Ceiling for a streaming run, which is allowed to be longer-lived than a request/response one. */
+    streamTimeoutMs?: number;
+    maxNodes?: number;
+    maxRequests?: number;
+    /**
+     * Bytes one outbound response may carry back into a flow.
+     *
+     * A timeout does not cover this: a backend answering a gigabyte quickly is a fast way to take a process down,
+     * and every other ceiling here is about how LONG a run may take rather than how much it may hold. Counted per
+     * response rather than per run, because it exists to stop one answer from being unbounded.
+     */
+    maxResponseBytes?: number;
+};
+/**
+ * A server action: a declarative flow, stored per space, executed by the server.
+ *
+ * It is the SAME document an element's interactions are — a map of steps, each naming a task, chained by
+ * `afterNode` — and it is deliberately nothing more. Everything that used to be declared beside the flow now lives
+ * on the step that starts it, so there is one place to read and one place to author, and the editor is the one
+ * already in the product.
+ *
+ * It lives in shared types because the builder authors the very document the server executes — the same reason
+ * `ConnectorManifest` does. It is server-side state: it goes to the BUILDER, which is authorized to edit it, and
+ * never into a page. What a visitor's page holds is the action's identifier, and what it gets back is whatever the
+ * output step named.
+ *
+ * There is no `enabled` here. Whether an action can run is whether any way INTO it is switched on, and that switch
+ * is the trigger step's own — one per way in, which is finer than one per action and is the control an author
+ * actually reaches for. A field beside the flow was the same fact written twice, with no rule for which won.
+ * Read it with `isActionEnabled` from `@plitzi/sdk-shared/actions`.
+ */
+export type ActionDocument = {
+    name: string;
+    description?: string;
+    /**
+     * The flows. One or more `trigger` steps, each heading a chain of `task` steps — the same node map an element's
+     * `interactions` holds, so one editor authors both.
+     */
+    nodes: Record<string, ElementInteraction>;
+    /**
+     * The keys the `flow.output` step names, DERIVED from it — never authored beside it.
+     *
+     * It exists so the builder can offer typed bindings on a call's result without opening the flow. Declaring it by
+     * hand was the original design and it was wrong: it asks an author to know what a flow returns before the steps
+     * that produce it exist, and it leaves two places to keep in step. The runner ignores this entirely and answers
+     * exactly what the output step named.
+     */
+    output?: Record<string, ActionField>;
+    limits?: ActionLimits;
+};
+/**
+ * An action as a server-side reader hands it over.
+ *
+ * `id` is stamped by the store rather than carried by the document, for the same reason `ConnectorManifestDraft`
+ * drops it: a document holding its own id can disagree with the one it was fetched by.
+ */
+export type ActionEntry = {
+    id: string;
+    document: ActionDocument;
+};
+/**
+ * One server task, as the builder's flow editor receives it.
+ *
+ * The catalog is served by the deployment rather than hardcoded, which is what lets a self-hoster's own task show
+ * up in their editor. `params` is the same `InteractionCallbackParam` map an interaction callback declares — but
+ * anything function-valued in it (a `when`, options computed from another param) does not survive the wire, so a
+ * task meant to be authored visually declares static params.
+ */
+export type ActionTaskDescriptor = {
+    name: string;
+    namespace: string;
+    action: string;
+    title: string;
+    description?: string;
+    params: Record<string, unknown>;
+};
+/**
+ * One run as an authoring caller receives it — the builder's test run.
+ *
+ * `trace` is the same `InteractionNode[]` the dev-tools panel renders, redacted of credential values. A visitor
+ * never sees it; an author looking at their own flow should see nothing less than the steps that ran.
+ */
+export type ActionRunReport = {
+    runId: string;
+    status: ActionRunStatus;
+    output: Record<string, unknown>;
+    trace: Record<string, unknown>[];
+};
+/**
+ * Whether the CLIENT flow waits. The server side is synchronous in every mode: `detached` means the step does not
+ * await its own request, not that the run outlives it.
+ */
+export type ActionCallMode = 'await' | 'detached' | 'stream';
+export type ActionRunStatus = 'completed' | 'failed' | 'skipped' | 'aborted';
+/**
+ * Why a run did not produce an answer. Reported to the caller — and to the `onFlowError` trigger — because a guard
+ * an author cannot observe is a guard they will work around.
+ */
+export type ActionErrorReason = 'not_found' | 'disabled'
+/**
+ * Nobody was signed in and the trigger asked for somebody.
+ *
+ * Separate from `forbidden` because the two ask different things of the caller: this one says "sign in again",
+ * and it is usually a session that ended under a page that still believes it has one — so the client reports it
+ * to auth, which renews or signs the visitor out at once. `forbidden` says "not you", and reading that as a dead
+ * session would sign out somebody who is merely short a permission.
+ */
+ | 'unauthenticated' | 'forbidden' | 'invalid_input'
+/** Another run holds this action's single-flight key. */
+ | 'duplicate'
+/** A concurrency or stream cap was reached. */
+ | 'over_capacity'
+/** The run's lineage already names this action: a loop through the outside world. */
+ | 'recursion' | 'timeout' | 'aborted' | 'failed';
+/**
+ * Why a request never became a run.
+ *
+ * A superset of {@link ActionErrorReason}: everything a run can be refused for, plus what only an inbound
+ * webhook can be refused for — the checks that happen before there is a document to run at all. They are named
+ * separately because they are the ones an author has to be able to SEE: a signature that does not match is a
+ * misconfiguration somebody has to fix, and it is indistinguishable from silence unless it is reported.
+ */
+export type ActionRejectReason = ActionErrorReason
+/** The signature did not verify against the raw body. */
+ | 'invalid_signature'
+/** This caller sent more deliveries this minute than the deployment allows. */
+ | 'rate_limited'
+/** The body was not JSON. */
+ | 'malformed_body'
+/** The trigger carries a signature check in a shape nothing reads, so the endpoint fails closed. */
+ | 'unverifiable';
+/**
+ * A request that was refused before it became a run.
+ *
+ * The counterpart to {@link ActionRunRecord}, and the reason it exists: `onRun` reports runs that STARTED, so a
+ * webhook rejected for a bad signature — the single most common way an integration is broken — produced nothing
+ * anybody could look at. Whether a refusal is worth keeping is the deployment's call: a duplicate delivery is a
+ * well-behaved sender retrying and is noise, while an invalid signature is somebody's afternoon. The mechanism
+ * reports all of them and filters none.
+ *
+ * Never carries the body or the signature. What went wrong is `detail`, in the server's own words.
+ */
+export type ActionRejectRecord = {
+    actionId: string;
+    spaceId: number;
+    environment: Environment;
+    trigger: ActionTriggerType;
+    reason: ActionRejectReason;
+    /** Why, for whoever has to fix it. Never the offending value itself. */
+    detail?: string;
+    /** Who asked, as the transport identifies them — a session subject or an address. */
+    callerId?: string;
+};
+/**
+ * What one run was, for whoever keeps the record.
+ *
+ * Emitted for every run that STARTED — completed, failed or aborted — and never for one refused before it began:
+ * a 409 is not a run, and logging it would bury the real ones under retries.
+ *
+ * Deliberately not the trace: step results are the space's own data and can be large, so what travels here is the
+ * shape of what happened. The trace goes to the author who asked for it, in the test-run panel.
+ */
+export type ActionRunRecord = {
+    runId: string;
+    actionId: string;
+    spaceId: number;
+    environment: Environment;
+    trigger: ActionTriggerType;
+    status: ActionRunStatus;
+    durationMs: number;
+    /** Who asked, when a session carried it. Absent for a webhook, a schedule or an anonymous visitor. */
+    userId?: number;
+    /** One entry per step that ran, in order — enough to see where a flow stopped without keeping its data. */
+    nodes: {
+        id: string;
+        action: string;
+        status: string;
+    }[];
+    /** Present when the run ended badly. Already redacted of credential values. */
+    error?: string;
+};
+/**
+ * One thing a CHECK found about an action, before anybody runs it.
+ *
+ * The complement to `validateActionDocument`, which reads the document alone and therefore cannot know whether
+ * the credential a step names exists, whether this server registers that task, or whether the cron would ever
+ * fire. Those are the failures that only show up at 3am on the first real delivery, and they are exactly what an
+ * author cannot see from the editor.
+ */
+export type ActionCheckIssue = {
+    /** `error` — it cannot work as written. `warning` — it will run, and somebody should know. */
+    level: 'error' | 'warning';
+    /** Where it is, in the same `nodes.<id>.params.<field>` shape the document validator uses. */
+    path: string;
+    message: string;
+    hint?: string;
+};
+/** What the deployment answered about one action. `valid` is "nothing here is fatal", not "it will succeed". */
+export type ActionCheckReport = {
+    valid: boolean;
+    issues: ActionCheckIssue[];
+};
+/**
+ * One thing that happened to an action, as the builder reads it back.
+ *
+ * A run and a refusal in one shape, because the question an author asks is "what happened", and the most common
+ * answer for a webhook is that nothing ran: the signature did not verify. `status: 'refused'` is that answer, and
+ * `reason` says which check turned it away.
+ *
+ * Never the trace — that belongs to the test run the author asked for. A history is which steps ran and how each
+ * ended, not what they held.
+ */
+export type ActionEvent = {
+    id: number;
+    actionId: string;
+    runId?: string | null;
+    trigger: string;
+    status: ActionRunStatus | 'refused' | 'unknown';
+    refused: boolean;
+    reason?: ActionRejectReason | null;
+    durationMs?: number | null;
+    steps: string[];
+    /** What went wrong, already redacted of credential values. */
+    detail?: string | null;
+    createdAt: number;
+};
+/** Action-addressed call. The element-addressed connector write keeps its own shape on the same endpoint. */
+export type ActionCallRequest = {
+    actionId: string;
+    input?: Record<string, unknown>;
+    /** Replaces the derived single-flight key, so a caller can make a retry provably the same run. */
+    idempotencyKey?: string;
+};
+export type ActionCallResult = {
+    runId: string;
+    status: ActionRunStatus;
+    output: Record<string, unknown>;
+};
+export type ActionCallError = {
+    runId?: string;
+    error: string;
+    reason: ActionErrorReason;
+};
+/** One frame of a streaming run. `node` frames are the trace arriving live; `data` frames are `stream.emit`. */
+export type ActionStreamFrame = {
+    event: 'node';
+    data: {
+        id: string;
+        status: string;
+    };
+} | {
+    event: 'data';
+    data: {
+        chunk: unknown;
+    };
+} | {
+    event: 'done';
+    data: ActionCallResult;
+} | {
+    event: 'error';
+    data: ActionCallError;
+};

package/dist/types/ActionTypes.mjs ADDED Viewed

File without changes

package/dist/types/AuthTypes.d.ts CHANGED Viewed

@@ -20,8 +20,13 @@ export type AuthState = 'init' | 'initLoading' | 'authenticating' | 'authenticat
  * Why a credential was refused, as reported by the auth backend (Plitzi's API answers it in `reason` on every 401).
  * The distinction that matters to a client is renewable versus not: `expired` asks for a refresh, `revoked`,
  * `inactive` and `missing` end the session, and `network` is not an answer at all — it must never sign anyone out.
+ *
+ * `unverified` is the one that is not about the credential: the password was right and the address has never answered.
+ * It is terminal like `inactive` — there is no session to be had — but it is the only refusal a person can do
+ * something about, which is why it is worth telling them apart. A sign-in screen that cannot distinguish them says
+ * "that email or password was not right" to somebody whose password was fine, and they try it again.
  */
-export type AuthFailureReason = 'missing' | 'expired' | 'revoked' | 'inactive' | 'malformed' | 'outdated' | 'network';
+export type AuthFailureReason = 'missing' | 'expired' | 'revoked' | 'inactive' | 'unverified' | 'malformed' | 'outdated' | 'network';
 /** What an auth backend hands back from a grant (login, refresh) or an identity call. Both halves are optional:
  *  a backend may answer a refresh with tokens alone, or an identity call with a user alone. */
 export type AuthGrant<U = Record<string, unknown>> = {
@@ -34,9 +39,25 @@ export type AuthResult<U = Record<string, unknown>> = ({
     ok: false;
     reason: AuthFailureReason;
 };
+/**
+ * What a sign-in came to: the session it minted, or why there is none.
+ *
+ * A bare `TokenResult | undefined` was not enough to write a sign-in screen with. Absence is every refusal at once —
+ * wrong password, unconfirmed address, blocked account, backend unreachable — so the only sentence a page could write
+ * under it was the one that covers all four, and it is wrong for three of them.
+ *
+ * The success half spreads a {@link TokenResult}, so `accessToken` is read off the outcome itself and a flow written
+ * against the old shape still finds it where it always was.
+ */
+export type LoginResult = ({
+    ok: true;
+} & TokenResult) | {
+    ok: false;
+    reason: AuthFailureReason;
+};
 export type AuthContextValue = {
     /** The credentials your login endpoint expects. Values arrive from interaction parameters, hence `unknown`. */
-    login: (params: Record<string, unknown>) => Promise<TokenResult | undefined>;
+    login: (params: Record<string, unknown>) => Promise<LoginResult>;
     refresh: (params?: Record<string, unknown>) => Promise<TokenResult | undefined>;
     can: (permission: string) => boolean;
     logout: () => Promise<void>;

package/dist/types/BuilderTypes.d.ts CHANGED Viewed

@@ -1,15 +1,3 @@
-import { Schema } from './SchemaTypes';
-import { Style } from './StyleTypes';
-export type Template = {
-    id?: string;
-    definition: {
-        name: string;
-        description: string;
-        baseElementId: Element['id'];
-    };
-    schema: Schema;
-    style: Style;
-};
 export type SubscriptionCollaboratorElement = {
     elementId: string;
     rootId: string;

package/dist/types/CommonTypes.d.ts CHANGED Viewed

@@ -9,6 +9,15 @@ export type Server<T extends Record<string, unknown> = Record<string, unknown>>
     domain?: string;
     requestUrl?: string;
     serverUrl: string;
+    /**
+     * Where this deployment serves the font files a space uploaded — a CDN prefix in the cloud, a path on the page
+     * server when it keeps them itself.
+     *
+     * Configuration rather than something to derive: a manifest holds store-relative paths precisely so that the
+     * origin is the deployment's answer, and an editor guessing it from the SSR host would address the CDN's files
+     * on the wrong origin. Absent means `/fonts` on whatever origin is rendering.
+     */
+    fontsBaseUrl?: string;
     websocketServer: string;
     subscriptionServer: string;
     location?: Location;
@@ -31,6 +40,10 @@ export type ServerSSR = {
     rscPath?: string;
     /** The payload that server already resolved for this page, so the first render costs no request. */
     rscData?: SSRRscData;
+    /** Path where this origin runs server actions. Published only by a server that mounts the endpoint: its absence
+     *  is what tells a client flow that a `serverAction` step has nowhere to run, rather than letting it fail per
+     *  click. A static export publishes nothing here and the step reports itself inert. */
+    actionPath?: string;
     /** Channel the SSR render writes its response into (status, redirect). Server-side only and by reference: it never
      *  crosses to the browser, and nothing subscribes to it. */
     renderResult?: SSRRenderResult;

package/dist/types/DevToolsTypes.d.ts CHANGED Viewed

@@ -3,7 +3,7 @@ import { NavigationStatus } from './NavigationTypes';
 import { ElementInteraction } from './SchemaTypes';
 import { ReactNode } from 'react';
 export type LogType = 'info' | 'warning' | 'danger' | 'success' | 'custom';
-export type LogCategory = 'navigation' | 'interactions' | 'store' | 'network';
+export type LogCategory = 'navigation' | 'interactions' | 'store' | 'network' | 'actions';
 export type LogNavigation = {
     category: 'navigation';
     params: {
@@ -15,19 +15,39 @@ export type LogEventBridge = {
     category: 'eventBridge';
     params: Record<string, unknown>;
 };
+/** A whole flow that ran, with every step it took. What `logInteraction` writes when a trigger finishes. */
+export type InteractionFlowParams = {
+    /** The SOURCE a global callback or utility named — `space`, `state` — not the element it ran on. */
+    elementId: string;
+    /** The id of the element the interaction fired on. What tells two identical-looking entries apart. */
+    hostElementId?: string;
+    startTime: number;
+    endTime: number;
+    node: ElementInteraction;
+    status: InteractionStatus;
+    nodes: Record<string, InteractionNode>;
+};
+/**
+ * A note about ONE step, written while a flow is still running.
+ *
+ * A step wired to a callback nobody registered, a `{{token}}` that would not resolve, a step that threw — all of
+ * them are reported the moment they happen, from inside the traversal, so none of them can carry the flow's
+ * summary. They were typed as though they did, and the panel rendered them as one: `Object.values(nodes)` on an
+ * entry that has no `nodes` took the whole dev-tools down with it, and only for people whose interactions were
+ * already misbehaving.
+ */
+export type InteractionNoteParams = {
+    node?: ElementInteraction;
+    /** The message of whatever was thrown, when a step failed rather than merely being misconfigured. */
+    error?: string;
+    /** What WAS registered under the element the step named, so a typo shows itself. */
+    available?: string[];
+    param?: string;
+    value?: unknown;
+};
 export type LogInteraction = {
     category: 'interactions';
-    params: {
-        /** The SOURCE a global callback or utility named — `space`, `state` — not the element it ran on. */
-        elementId: string;
-        /** The idRef of the element the interaction fired on. What tells two identical-looking entries apart. */
-        elementRef?: string;
-        startTime: number;
-        endTime: number;
-        node: ElementInteraction;
-        status: InteractionStatus;
-        nodes: Record<string, InteractionNode>;
-    };
+    params: InteractionFlowParams | InteractionNoteParams;
 };
 export type LogStore = {
     category: 'store';
@@ -38,6 +58,29 @@ export type LogStore = {
         next: unknown;
     };
 };
+/**
+ * A server action this page started, as a log line.
+ *
+ * Its own category rather than an `interactions` entry: an action is not a step that ran in the browser, and the
+ * things worth reading about one — which way in, the server's run id, the reason it was refused — have no place
+ * in a client flow's shape. The Actions tab shows the run in full; this is the line that says it happened, in the
+ * stream where everything else the page did is already ordered.
+ */
+export type LogAction = {
+    category: 'actions';
+    params: {
+        actionId: string;
+        /** `await`, `detached`, `stream` — or `cancel` for a run somebody stopped. */
+        mode?: string;
+        /** The server's own id, once there is one. */
+        runId?: string;
+        status?: string;
+        /** The server's vocabulary when it refused: `duplicate`, `over_capacity`, `recursion`, `forbidden`… */
+        reason?: string;
+        error?: string;
+        output?: Record<string, unknown>;
+    };
+};
 /** Something that arrived from the server and was not what it claimed to be — a space event failing its schema. */
 export type LogNetwork = {
     category: 'network';
@@ -50,10 +93,10 @@ export type LogNetwork = {
         payload?: unknown;
     };
 };
-export type LogParams = LogNavigation['params'] | LogInteraction['params'] | LogEventBridge['params'] | LogStore['params'] | LogNetwork['params'];
+export type LogParams = LogNavigation['params'] | LogInteraction['params'] | LogEventBridge['params'] | LogStore['params'] | LogNetwork['params'] | LogAction['params'];
 export type Log = {
     logType: string;
     message: ReactNode;
     time?: string;
-} & (LogInteraction | LogNavigation | LogEventBridge | LogStore | LogNetwork);
+} & (LogInteraction | LogNavigation | LogEventBridge | LogStore | LogNetwork | LogAction);
 export type ProviderCallback = (...args: unknown[]) => Record<string, unknown>;

package/dist/types/EventBridgeTypes.d.ts CHANGED Viewed

@@ -2,4 +2,4 @@ export type EventBridgeContextValue<T = any> = {
     eventBridge: T;
 };
 export type EventBridgeModule = 'main' | 'builder' | 'segment' | 'template' | 'interaction' | 'element';
-export type EventBridgeEvent = 'schemaAddPage' | 'schemaHomePage' | 'schemaUpdatePage' | 'schemaRemovePage' | 'schemaAddPageFolder' | 'schemaUpdatePageFolder' | 'schemaRemovePageFolder' | 'schemaUpdateSettings' | 'schemaUpdate' | 'schemaAddElement' | 'schemaUpdateElement' | 'schemaUpdateElements' | 'schemaRemoveElement' | 'schemaMoveElement' | 'schemaCloneElement' | 'schemaAddVariable' | 'schemaUpdateVariable' | 'schemaRemoveVariable' | 'schemaAddTemplate' | 'styleUpdate' | 'styleAddSelector' | 'styleUpdateSelector' | 'styleRemoveSelector' | 'styleRemoveSelectors' | 'styleAddSelectorVariable' | 'styleUpdateSelectorVariable' | 'styleRemoveSelectorVariable' | 'styleAddVariable' | 'styleUpdateVariable' | 'styleRemoveVariable' | 'styleAddTemplate' | 'styleUpdateSettings' | 'builderSetBaseContext' | 'builderSetSelected' | 'builderSetHovered';
+export type EventBridgeEvent = 'schemaAddPage' | 'schemaHomePage' | 'schemaUpdatePage' | 'schemaRemovePage' | 'schemaAddPageFolder' | 'schemaUpdatePageFolder' | 'schemaRemovePageFolder' | 'schemaUpdateSettings' | 'schemaUpdate' | 'schemaAddElement' | 'schemaUpdateElement' | 'schemaRenameElement' | 'schemaUpdateElements' | 'schemaRemoveElement' | 'schemaMoveElement' | 'schemaCloneElement' | 'schemaAddVariable' | 'schemaUpdateVariable' | 'schemaRemoveVariable' | 'schemaAddTemplate' | 'styleUpdate' | 'styleAddSelector' | 'styleUpdateSelector' | 'styleRemoveSelector' | 'styleRemoveSelectors' | 'styleAddSelectorVariable' | 'styleUpdateSelectorVariable' | 'styleRemoveSelectorVariable' | 'styleAddVariable' | 'styleUpdateVariable' | 'styleRemoveVariable' | 'styleAddFont' | 'styleUpdateFont' | 'styleRemoveFont' | 'styleAddTemplate' | 'styleUpdateSettings' | 'builderSetBaseContext' | 'builderSetSelected' | 'builderSetHovered';

package/dist/types/InteractionTypes.d.ts CHANGED Viewed

@@ -1,6 +1,6 @@
 import { ElementInteraction } from './SchemaTypes';
 import { RuleValue } from '@plitzi/plitzi-ui/QueryBuilder';
-export type InteractionCallbackType = 'trigger' | 'globalCallback' | 'callback' | 'utility';
+export type InteractionCallbackType = 'trigger' | 'globalCallback' | 'callback' | 'utility' | 'task';
 export type InteractionStatus = 'completed' | 'skipped' | 'failed';
 export type InteractionNodeStatus = 'success' | 'failed' | 'skipped' | 'disabled';
 export type InteractionPostCallback<T extends Record<string, unknown> = Record<string, unknown>> = (params: InteractionCallbackParamValues<T>, callbackResult?: unknown) => unknown;
@@ -62,15 +62,25 @@ export type InteractionCallbackParam<T extends Record<string, unknown> = Record<
 });
 export type InteractionCallbackPreview = string | Record<string, unknown>;
 export type InteractionCallbackPreviews = Record<string, InteractionCallbackPreview>;
+/**
+ * What a callback learns about the flow running it.
+ *
+ * Only the element the flow fired on, and only because a step that starts something asynchronous has to be able to
+ * report back TO that element — a server action running detached finishes long after the flow that launched it
+ * returned, and `onFlowEnd` has to fire somewhere specific.
+ */
+export type InteractionCallbackContext = {
+    /** Id of the element this flow fired on. Absent for a flow with no host element. */
+    hostElementId?: string;
+};
 export type InteractionCallback<T extends Record<string, unknown> = Record<string, unknown>> = {
     elementId?: string;
     action: string;
     title: string;
     type: InteractionCallbackType;
     enabled?: boolean;
-    unreferenced?: boolean;
     params: Record<keyof T, InteractionCallbackParam<T>> | ((params: InteractionCallbackParamValues<T>) => Record<keyof T, InteractionCallbackParam<T>>);
-    callback?: (params: InteractionCallbackParamValues<T>) => unknown;
+    callback?: (params: InteractionCallbackParamValues<T>, context?: InteractionCallbackContext) => unknown;
     postCallback?: InteractionPostCallback<T>;
     preview?: InteractionCallbackPreviews | ((params: InteractionCallbackParamValues<T>) => InteractionCallbackPreviews);
 };
@@ -100,3 +110,13 @@ export type InteractionsContextValue<TManager = any> = {
         getAdditionalParams?: Subscriptor<T>['getAdditionalParams'];
     }) => void;
 };
+/**
+ * What an embedding application offers a space it renders.
+ *
+ * The one direction that did not exist: a space acts on its own state, its own router and its own session, and had
+ * no way to ask the application AROUND it for anything — so every application shell had to be written in the host's
+ * own code, which is the one part of a product that cannot then be authored or themed without a release.
+ *
+ * Keyed by the name a space's `hostAction` step calls. A name the host did not register does nothing.
+ */
+export type HostActions = Record<string, (params: Record<string, unknown>) => void>;

package/dist/types/PluginTypes.d.ts CHANGED Viewed

@@ -92,15 +92,12 @@ export type Plugin = {
     isMain?: boolean;
     manifest: PluginManifest;
     market: ComponentDefinition['market'];
-    module: string;
     resource: string;
-    scope: string;
     settings: Record<string, unknown>;
     subPlugins?: string[];
     type: string;
 };
 export type PluginsContextValue = {
-    baseAssets?: Record<string, Asset>;
     assets: Record<string, Asset>;
     plugins: Record<string, ComponentDefinition>;
     dispatchPlugins?: unknown;