@w6w/embed 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,105 @@
+# Functional Source License, Version 1.1, ALv2 Future License
+
+## Abbreviation
+
+FSL-1.1-ALv2
+
+## Notice
+
+Copyright 2026 w6w-io
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly display
+and redistribute the Software for any Permitted Purpose identified below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software under
+the Apache License, Version 2.0 that is effective on the second anniversary of
+the date we make the Software available. On or after that date, you may use the
+Software under the Apache License, Version 2.0, in which case the following
+will apply:
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License.
+
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.

package/README.md

@@ -1,3 +1,167 @@
-# Temporary Holding Version
+# @w6w/embed
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Embed w6w in a host React app: one provider that wires the w6w API client, `@w6w/ui`'s components
+and an identity-scoped query cache to your own sign-in, and a managed workflow editor
+(`<WorkflowEditor>`) you mount as a route.
+
+License: [FSL-1.1-ALv2](./LICENSE) (Functional Source License). This package is
+**source-available**, not open source: the licence's Competing-Use clause applies, and each version
+converts to Apache-2.0 after two years. `@w6w/sdk`, `@w6w/react` and `@w6w/ui`, which it depends on,
+stay MIT.
+
+## Install
+
+```sh
+npm i @w6w/embed react react-dom
+```
+
+That is the only w6w package you install. `@w6w/sdk`, `@w6w/react`, `@w6w/ui` and
+`@tanstack/react-query` come with it as dependencies; `react` and `react-dom` (18 or later) are
+yours. Import the one stylesheet once, at your app's root:
+
+```ts
+import "@w6w/embed/styles.css"; // @w6w/ui's styles, React Flow base included
+```
+
+## The provider
+
+```tsx
+import { W6WEmbedProvider } from "@w6w/embed";
+
+function Host({ user }: { user: { id: string; accountId: string } }) {
+  return (
+    <W6WEmbedProvider
+      apiOrigin="https://api.w6w.io"
+      identityKey={`${user.id}:${user.accountId}`}
+      getSession={() => fetch("/api/w6w-session", { method: "POST" }).then((r) => r.json())} // -> {token, expiresAt}
+      project="proj_123" // optional default project, see "The project rule"
+      theme="dark" // optional: follow your host's theme
+    >
+      {/* @w6w/ui components, @w6w/react hooks and <WorkflowEditor> work here */}
+    </W6WEmbedProvider>
+  );
+}
+```
+
+`getSession` calls an endpoint on **your** backend that mints an account-scoped session for the
+signed-in user with `createEmbedSessionClient` from `@w6w/sdk/server`; the tenant client secret
+never reaches the browser. The recipe is in the guide at `/guides/embed/`.
+
+- `identityKey` names who is signed in. When it changes, the API client **and** the query cache are
+  replaced and the subtree re-mounts, so nothing cached for the previous identity is shown to the
+  next one.
+- The provider owns its `QueryClient`; it does not use, and does not need, one from your app.
+- `ready={false}` holds every read until you have a user; `project` sets the default project.
+
+### Next.js server components
+
+A server component cannot pass a plain function to a client component, so a `getSession` written
+inline there does not work. Define it as an inline server action instead:
+
+```tsx
+// app/page.tsx (a server component)
+import { createEmbedSessionClient } from "@w6w/sdk/server";
+import { W6WEmbedProvider } from "@w6w/embed";
+import { currentUser } from "./your-auth"; // YOUR server-side session lookup
+
+const sessions = createEmbedSessionClient({
+  baseUrl: process.env.W6W_BASE_URL!,
+  clientId: process.env.W6W_TENANT_CLIENT_ID!,
+  clientSecret: process.env.W6W_TENANT_CLIENT_SECRET!, // stays on the server
+});
+
+export default async function Page() {
+  const user = await currentUser(); // from your own session, on the server
+  if (!user) return null;
+
+  async function getSession() {
+    "use server";
+    const u = await currentUser(); // no arguments: who is signed in comes from the server
+    if (!u) throw new Error("unauthenticated");
+    const s = await sessions.create({ subject: u.id, accountRef: u.companyId });
+    return { token: s.token, expiresAt: s.expiresAt }; // nothing else leaves the server
+  }
+
+  return (
+    <W6WEmbedProvider
+      apiOrigin={process.env.W6W_BASE_URL!}
+      identityKey={`${user.id}:${user.companyId}`} // the same server-side user
+      getSession={getSession}
+    >
+      {/* a client component renders <WorkflowEditor> here */}
+    </W6WEmbedProvider>
+  );
+}
+```
+
+A server action is a public POST endpoint: anyone can call it with any arguments. So `getSession`
+must **never accept the subject or the account from its caller**, and takes no arguments at all.
+It reads the signed-in user from your own server-side session, mints for that user only, and
+returns only `{ token, expiresAt }`. The tenant client secret stays on the server, and
+`identityKey` is computed from the same server-side user. In a client component, the `fetch` form
+above stays the default.
+
+## The editor
+
+Mount the managed editor as a route in your app. It is loaded lazily, so it adds nothing to your
+bundle until the route renders:
+
+```tsx
+import { WorkflowEditor } from "@w6w/embed/editor";
+
+function WorkflowRoute({ workflowId }: { workflowId: string }) {
+  return (
+    <WorkflowEditor
+      workflowId={workflowId}
+      project="proj_123" // optional when the provider has one
+      onNavigate={(to) => {/* route inside your app */}}
+    />
+  );
+}
+```
+
+Props: `workflowId` (required), `project`, `initialRunId`, `onNavigate` and `slots`. `onNavigate` is
+optional (default: a no-op) and hands navigation (back to the list, or to another workflow) to your
+router; `slots` lets you place your own elements in the editor chrome; `initialRunId` opens the
+editor on a run. The editor must render inside `<W6WEmbedProvider>`.
+
+### The project rule
+
+The editor takes its project from its `project` prop, else from the provider's `project`. Saves
+never fall back to the account's default project, because a save without a project would silently
+move the workflow. With neither set (or with `project={null}` or `""`, which refuses even when the
+provider has one), the editor opens with saving and publishing disabled and a "project required"
+message.
+
+### Autosave and switching identity
+
+Edits autosave. When `identityKey` changes, a pending save is first flushed into the account it
+belongs to, and only then does the provider swap to the new identity. There is no discard path: a
+save that fails or times out does not block the switch, and is never retried into the new account.
+
+### Theming
+
+The editor's chrome is styled by the same `@w6w/embed/styles.css`. Every rule is scoped under the
+editor's root element, class `w6w-embed-root`, so it does not leak into your page. The palette
+comes from the nearest `[data-theme]` ancestor: the provider's `theme` prop puts one around the
+tree. Omit `theme` and the editor follows `data-theme` on `<html>` if you set it, else the OS
+preference. The editor fills its parent (`width` and `height` 100%), so give its container a height.
+
+## Console exclusions
+
+Your host code makes no `client.console` call. The package uses a public `@w6w/sdk` operation
+wherever one exists, and every remaining `client.console` or raw `request()` site is listed here
+with its reason.
+
+| File | Call | Reason |
+| --- | --- | --- |
+| `src/repos/workflows.ts` | `console.workflows.listRuns`, `console.workflows.getRun` + `pollRunToTerminal` | no public run-list or run-get operation; the run poll is what the Run feature needs |
+| `src/repos/workflows.ts` | `console.workflows.upsert` | creating a workflow in a named project has no public operation |
+| `src/lib/history-query.ts` | `console.workflows.getRun`; raw `GET /history`, `GET /history/stats`, `GET /invocations/:id` | no public history or invocation operation |
+| `src/repos/step-tests.ts` | `console.stepTests.list`, `.save`, `.recordRun` | no public operation |
+| `src/repos/vault.ts` | `console.vault.list`, `.seal`, `.create`, `.update`, `.delete` | vault is outside the public contract; used to add and seal a secret from the expression editor |
+| `src/repos/documents.ts` | raw `POST /documents/:id/sync` | no public operation |
+| `src/repos/spec-import.ts` | raw `POST /spec/import` | no public operation (Settings import) |
+| `src/repos/vars.ts` | raw `GET /vars`, `POST /vars`, `PATCH /vars/:id`, `DELETE /vars/:id` | the SDK's `vars` methods take no options argument, so they cannot send `?project=` |
+| `src/repos/versions.ts` | raw `GET /:c/:id/versions`, `GET /:c/:id/versions/:v`, `POST /:c/:id/publish`, `POST /:c/:id/:x`, `POST /:c/:id/versions/:v/revert`, `POST /:c/:id/versions/:v/:x` | the endpoint arm has no public version operation; the function arm of invoke-version keeps the raw invocation frame, which `functions.runVersion` unwraps |
+| `@w6w/react` `createW6WUiAdapter` (canvas) | `console.apps.*`, saved and step tests, subscriptions | the adapter's own call sites, used by the canvas from `@w6w/ui/flow` |

package/dist/W6WEmbedProvider.d.ts

@@ -0,0 +1,29 @@
+import { W6WSession } from '@w6w/react';
+import { FetchLike } from '@w6w/sdk';
+import { ThemeMode } from '@w6w/ui';
+import { ReactNode } from 'react';
+export interface W6WEmbedProviderProps {
+    /** The w6w API origin, e.g. `"https://api.w6w.io"`. */
+    apiOrigin: string;
+    /**
+     * Mints a session for the CURRENT host user (`{token, expiresAt, expiresIn?}`). Always the
+     * latest callback; the provider caches and renews the result.
+     */
+    getSession: () => Promise<W6WSession>;
+    /**
+     * Which signed-in identity this provider speaks for (e.g. `${userId}:${accountId}`). Changing it
+     * rebuilds the API client AND replaces the `QueryClient`, so nothing cached for the previous
+     * identity is ever shown under the new one.
+     */
+    identityKey: string;
+    /** Force the `@w6w/ui` theme to follow the host's. Omit to resolve it the library's default way. */
+    theme?: ThemeMode;
+    /** Gates every read hook while `false` (default `true`) — e.g. until the host has a user. */
+    ready?: boolean;
+    /** Default project id for project-scoped operations. */
+    project?: string;
+    /** Transport override (tests, request recording). Defaults to `globalThis.fetch`. */
+    fetch?: FetchLike;
+    children: ReactNode;
+}
+export declare function W6WEmbedProvider({ apiOrigin, getSession, identityKey, theme, ready, project, fetch, children, }: W6WEmbedProviderProps): ReactNode;

package/dist/chrome/CallFromCodeButton.d.ts

@@ -0,0 +1,155 @@
+import { SnippetCallable, TriggerPreview } from '@w6w/embed/lib';
+/**
+ * "Call from code" — the button that shows how to reach the thing you are
+ * looking at from the Node SDK (`@w6w/sdk`), the CLI (`w6w`), or the Python
+ * SDK (`w6w`, PyPI).
+ *
+ * Mounted on the pages whose resource the wrapper contract actually covers.
+ * Everything shown comes from `../lib/sdk-snippets.ts`, which builds against
+ * `packages/wrappers/endpoints.json` — this component owns presentation only
+ * and never composes an API call of its own.
+ *
+ * A modal rather than an inline block: the snippet is reference material a
+ * reader wants once and then dismisses, and inlining it would push the page's
+ * real content (a function's inputs, a workflow's steps) below the fold for
+ * everyone who is not currently writing a client.
+ */
+/**
+ * Tabs, in the order the contract lists the wrappers — then `curl`, which is
+ * not a wrapper at all and therefore comes last.
+ *
+ * The strip renders only the tabs the BUILT snippet actually carries
+ * (`Snippet.curl` is optional): a Function, Endpoint or Workflow shows all
+ * four tabs, while a Connection, Var or Document — which have no fixed
+ * single-resource route to curl against — still show exactly the three
+ * Node/CLI/Python tabs they show today.
+ */
+declare const TABS: readonly [{
+    readonly id: "node";
+    readonly label: "Node";
+    readonly language: "TypeScript";
+    readonly grammar: "typescript";
+    readonly icon: "lang-node";
+}, {
+    readonly id: "cli";
+    readonly label: "CLI";
+    readonly language: "Shell";
+    readonly grammar: "bash";
+    readonly icon: "terminal";
+}, {
+    readonly id: "python";
+    readonly label: "Python";
+    readonly language: "Python";
+    readonly grammar: "python";
+    readonly icon: "lang-python";
+}, {
+    readonly id: "curl";
+    readonly label: "curl";
+    readonly language: "Shell";
+    readonly grammar: "bash";
+    readonly icon: "lang-curl";
+}];
+/**
+ * The tab table, exported so a caller can render its OWN affordance per
+ * language without re-deriving the set. `CodeTool`'s rail panel uses it to draw
+ * one icon per language and open this component's modal on that language.
+ *
+ * Exported as the table rather than as a list of ids on purpose: label, grammar
+ * and glyph belong to the same row, and a second place that decided "which
+ * languages exist" would be a second place to forget `curl`.
+ */
+export declare const SNIPPET_TABS: readonly [{
+    readonly id: "node";
+    readonly label: "Node";
+    readonly language: "TypeScript";
+    readonly grammar: "typescript";
+    readonly icon: "lang-node";
+}, {
+    readonly id: "cli";
+    readonly label: "CLI";
+    readonly language: "Shell";
+    readonly grammar: "bash";
+    readonly icon: "terminal";
+}, {
+    readonly id: "python";
+    readonly label: "Python";
+    readonly language: "Python";
+    readonly grammar: "python";
+    readonly icon: "lang-python";
+}, {
+    readonly id: "curl";
+    readonly label: "curl";
+    readonly language: "Shell";
+    readonly grammar: "bash";
+    readonly icon: "lang-curl";
+}];
+type TabId = (typeof TABS)[number]["id"];
+export type SnippetTabId = TabId;
+/**
+ * Which language tabs a resource actually has — the same filter the strip
+ * below applies, hoisted so a caller can ask BEFORE rendering.
+ *
+ * `curl` is emitted only where a public URL exists and was handed in (today: a
+ * Function, a Workflow, or an Endpoint that knows its own server-rendered URL),
+ * so a var, document or connection yields exactly Node/CLI/Python. Trigger
+ * fields are deliberately not a parameter: they change what the snippet SAYS,
+ * never which languages it is available in.
+ *
+ * Empty when the resource has no snippet at all — the caller should then show
+ * {@link unavailableReason} rather than an empty row of icons.
+ */
+export declare function snippetTabsFor(resource: SnippetCallable): readonly (typeof TABS)[number][];
+/**
+ * The headless body — everything that renders the snippet itself: the
+ * trigger-tab strip, the language-tab strip, the `CodeBlock`, and the per-tab
+ * install-hint paragraph. No button, no `Modal`. Split out (T2.1.2) so
+ * `CodeTool.Panel` (`../ui/rail/CodeTool.tsx`) can render this INSIDE the
+ * right rail's own already-open panel, without a second trigger button or a
+ * Modal-on-top-of-a-panel double-wrap — the rail's strip + panel disclosure
+ * IS the trigger; this component only needs to draw what's inside it.
+ * `CallFromCodeButton` below is unchanged in outward shape: the same button +
+ * `Modal`, now rendering this body inside.
+ */
+export declare function CallFromCodeBody({ resource, triggers, wrap, maxHeight, initialTab, }: {
+    resource: SnippetCallable;
+    /**
+     * The workflow's declared manual (`@w6w/trigger`) triggers, one entry per
+     * step, in declared order — optional so every other `CallFromCodeBody`
+     * caller (function, endpoint, connection, var, document) is unaffected.
+     * Both call sites derive this from a workflow definition already in scope
+     * (T2.2.1, HITL-2/HITL-4 pinned); nothing here fetches it. The selected
+     * trigger's declared fields are passed straight into `buildSnippet` and
+     * rendered INSIDE the generated code — required fields as active code with
+     * a type-derived placeholder, optional fields commented out (D-3/D-4) — so
+     * there is nothing left to duplicate in a panel above it.
+     */
+    triggers?: TriggerPreview[];
+    /**
+     * Soft-wrap the code box instead of scrolling it horizontally. Default OFF
+     * — see the `CodeBlock` call below for why off is right wherever there is
+     * room, and why the right rail is the place where it is not.
+     */
+    wrap?: boolean;
+    /** The code box's max height. Default `"420px"`, the modal's size. */
+    maxHeight?: string;
+    /**
+     * Which language to open on. Seeds the selection ONCE, at mount — this is a
+     * starting point, not a controlled value, so the strip stays clickable
+     * afterwards.
+     *
+     * That "once" is load-bearing for the rail: `CodeTool` mounts this inside a
+     * modal that is conditionally rendered, so picking Python, closing, and
+     * picking Node re-mounts and re-seeds. A tab this resource does not carry
+     * falls back to the first one it does, via `activeTab` below.
+     */
+    initialTab?: TabId;
+}): import("react").JSX.Element;
+export declare function CallFromCodeButton({ resource, label, triggers, initialTab, }: {
+    resource: SnippetCallable;
+    label?: string;
+    /** See {@link CallFromCodeBody}'s own doc — passed straight through. */
+    triggers?: TriggerPreview[];
+    /** See {@link CallFromCodeBody}'s own doc — passed straight through. */
+    initialTab?: TabId;
+}): import("react").JSX.Element;
+export {};

package/dist/chrome/CallableSettingsModal.d.ts

@@ -0,0 +1,17 @@
+interface CallableSettingsModalProps {
+    kind: "function" | "endpoint" | "workflow";
+    id: string;
+    initial: {
+        displayName: string;
+        key: string | null;
+        tags?: string[];
+    };
+    onSave: (data: {
+        displayName: string;
+        key: string | null;
+        tags?: string[];
+    }) => Promise<void>;
+    onClose: () => void;
+}
+export declare function CallableSettingsModal(props: CallableSettingsModalProps): import("react").JSX.Element;
+export {};

package/dist/chrome/ConfirmModal.d.ts

@@ -0,0 +1,20 @@
+interface ConfirmModalProps {
+    title: string;
+    message: string;
+    /** Fired when the user confirms. The caller clears its pending state via onClose. */
+    onConfirm: () => void;
+    /** Fired on Cancel, Esc, or outside-click — dismisses without confirming. */
+    onClose: () => void;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    /** Style the confirm button as destructive (default true — this dialog gates dangerous actions). */
+    destructive?: boolean;
+}
+/**
+ * A reusable confirmation dialog built on our <dialog>-based Modal, so it inherits
+ * focus-trap, Esc-dismiss, and outside-click close. Replaces the browser's native
+ * confirmation prompt for destructive actions: Confirm fires `onConfirm`;
+ * Cancel/Esc/outside-click fires `onClose` only (no confirmation).
+ */
+export declare function ConfirmModal({ title, message, onConfirm, onClose, confirmLabel, cancelLabel, destructive, }: ConfirmModalProps): import("react").JSX.Element;
+export {};

package/dist/chrome/DangerZone.d.ts

@@ -0,0 +1,19 @@
+export interface DangerZoneProps {
+    /** Whether the resource is archived yet. `true` renders Delete; `false`
+     *  renders Archive. Every kind has an archive-before-delete step as of
+     *  T4.1.1 (Function/Endpoint newly, Workflow already did). */
+    archived: boolean;
+    /** Accessible name for the Delete icon button — `title`/`aria-label` only
+     *  (`IconButton.tsx`), e.g. "Delete this function". */
+    deleteLabel: string;
+    /** `data-testid` for the Delete control. Kind-specific — page guards key
+     *  on these directly (e.g. `delete-function`, `wf-settings-delete`). */
+    deleteTestId: string;
+    /** `data-testid` for the Archive control. Kind-specific. */
+    archiveTestId: string;
+    onRequestDelete: () => void;
+    onRequestArchive: () => void;
+    deleteError: string | null;
+    archiveError: string | null;
+}
+export declare function DangerZone(props: DangerZoneProps): import("react").JSX.Element;

package/dist/chrome/ExecutionProfileHeader.d.ts

@@ -0,0 +1,69 @@
+import { ReactNode } from 'react';
+/**
+ * `ExecutionProfileHeader` — the ONE editor header every execution profile's
+ * editor mounts (T3.1.1, `building-blocks.md` §Profile building blocks
+ * §Mirror).
+ *
+ * Extracted verbatim from `WorkflowsPage.tsx`'s full-bleed editor head, which
+ * is the presentation of record: back control, title, actions. Two hosts use
+ * it with two title CONFIGURATIONS, never two headers:
+ *   - `WorkflowsPage.tsx` — an inline-editable, controlled name input
+ *     (`editable: true`); back clears the `?edit=` search param; the action row
+ *     (run / stop / publish / JSON / settings) stays host-owned and arrives as
+ *     `actions`.
+ *   - `CallablePage.tsx`'s `CallableEditorChrome` — a Function/Endpoint
+ *     read-only heading (`editable: false`) with the `incomplete` badge passed
+ *     as `titleAdornment`, and the host's own JSON toggle then Save button as
+ *     `actions`.
+ *
+ * Presentation only: no query, mutation or navigation logic lives here — every
+ * callback (`onBack`, `onChange`, `onBlur`) and every node in the action row is
+ * the host's, mirroring the `ConnectionHeader.tsx` action-slot precedent.
+ *
+ * The rendered DOM of the Workflow editor's header is byte-for-byte what it
+ * was before the extraction (`wf-fullbleed-head` / `wf-back-btn` /
+ * `wf-title-input` / `wf-head-actions`, every `data-testid`, the `aria-label`
+ * and the attribute order), which is what `styles.css`'s
+ * `.wf-fullbleed-head input.wf-title-input` ancestor specificity and the
+ * workflow header screenshot guard both depend on.
+ */
+/** The editable title variant: the Workflow editor's inline-editable name. */
+export interface EditableProfileTitle {
+    /** The controlled value. */
+    value: string;
+    /** Called with the new text on every keystroke. */
+    onChange: (next: string) => void;
+    /** Called when the field loses focus — the Workflow host saves here. */
+    onBlur: () => void;
+    /** Shown while the value is empty; also the field's minimum sizing basis. */
+    placeholder: string;
+    /** The `maxLength` the input carries. */
+    maxLength: number;
+    /** The input's accessible name. */
+    ariaLabel: string;
+}
+/** The read-only title variant: a Function/Endpoint editor's heading text. */
+export interface ReadOnlyProfileTitle {
+    value: string;
+}
+/** Which title the host mounts. The discriminant is `editable`. */
+export type ExecutionProfileTitle = ({
+    editable: true;
+} & EditableProfileTitle) | ({
+    editable: false;
+} & ReadOnlyProfileTitle);
+export interface ExecutionProfileHeaderProps {
+    /** The back control's click handler — host-owned (the Workflow host clears
+     *  `?edit=`; `CallableEditorChrome` navigates to the kind's listing). */
+    onBack: () => void;
+    /** The back control's visible text — host-owned copy (`"← Workflows"`,
+     *  `descriptor.editor.backLabel`). */
+    backLabel: string;
+    /** Editable (Workflow) or read-only (Function/Endpoint) title. */
+    title: ExecutionProfileTitle;
+    /** Rendered immediately after a read-only title — the `incomplete` badge. */
+    titleAdornment?: ReactNode;
+    /** The host's action row (buttons only; this component owns the wrapper). */
+    actions: ReactNode;
+}
+export declare function ExecutionProfileHeader({ onBack, backLabel, title, titleAdornment, actions, }: ExecutionProfileHeaderProps): import("react").JSX.Element;

package/dist/chrome/HistoryButton.d.ts

@@ -0,0 +1,8 @@
+import { CallableKind } from '@w6w/embed/repos';
+export interface HistoryButtonProps {
+    kind: CallableKind;
+    id: string;
+    /** Forwarded to the modal; see `HistoryModalProps.onOpenRun`. */
+    onOpenRun?: (runId: string) => void;
+}
+export declare function HistoryButton(props: HistoryButtonProps): import("react").JSX.Element;

package/dist/chrome/HistoryModal.d.ts

@@ -0,0 +1,9 @@
+import { CallableKind } from '@w6w/embed/repos';
+export interface HistoryModalProps {
+    kind: CallableKind;
+    id: string;
+    onClose: () => void;
+    /** Open a workflow run in the host's editor; absent ⇒ no open-in-editor affordance. */
+    onOpenRun?: (runId: string) => void;
+}
+export declare function HistoryModal(props: HistoryModalProps): import("react").JSX.Element;

package/dist/chrome/HistoryView.d.ts

@@ -0,0 +1,15 @@
+import { ExecutionSummary, HistoryFilters, HistoryScope } from '@w6w/embed/repos';
+export interface HistoryViewProps {
+    /** `null` ⇒ no scope known yet (the project-wide host, before its project
+     *  resolves) — both queries stay disabled, mirroring `repos/history.ts`'s
+     *  own `enabled: scope !== null`. */
+    scope: HistoryScope | null;
+    /** Project-wide chrome: the Kind filter, and the Callable column on every
+     *  row. A per-callable host (every callable already knows its own kind)
+     *  passes `false`. */
+    showKind: boolean;
+    filters: HistoryFilters;
+    onFiltersChange: (next: HistoryFilters) => void;
+    onOpenInEditor?: (execution: ExecutionSummary) => void;
+}
+export declare function HistoryView(props: HistoryViewProps): import("react").JSX.Element;

package/dist/chrome/ImportSpecModal.d.ts

@@ -0,0 +1,40 @@
+import { SpecImportKind, SpecImportListKeys } from '@w6w/embed/lib';
+/**
+ * Import modal for the Functions, Endpoints and Workflows lists (T1.2.1, generalizing T3.2.1's
+ * Functions-only `ImportFunctionModal`): paste a portable spec document (rfcs/function.md), POST
+ * it to `/spec/import` and either land in the created resource's editor (every reference resolved)
+ * or stay open with the unresolved-reference report (A5).
+ *
+ * **P1 — one parameterized component, not three.** The Function-specific surface was four strings,
+ * one nav target and a testid prefix — forking it into three siblings would duplicate the state
+ * machine below for no gain. The `kind` prop drives all of it: `parseImportPaste`'s expected kind,
+ * the title/copy, the `goto()` navigation target (`<collection>/<id>`), and every testid (P2 — the
+ * four `functions-import-*` ones this file used to hardcode keep matching byte-for-byte; see
+ * `TESTIDS` above for why they are spelled out literally per kind rather than interpolated).
+ *
+ * Mirrors `FunctionIdentityModal.tsx` (note 3 — same studio-local `Modal`,
+ * same `ApiError.message` handling, same "the row was created, hand the
+ * operator the id" shape as `onCreated`) but is a structurally PARALLEL,
+ * distinct trigger — not a second "create a resource and land in its editor"
+ * flow built on top of it. It owns its own navigation (unlike the identity
+ * modal, which reports back to the list) because A5's "created but
+ * partially resolved" outcome has nowhere else to render the report: the
+ * modal has to stay mounted to show it, so it is also the one place that can
+ * decide whether and when to leave the list route.
+ *
+ * **A `201` whose `references` carry any `resolved: false` entry is NOT
+ * "done" (A5)** — the near-miss this exists to kill is "201 ⇒ close and
+ * navigate", which would hide exactly the unresolved-reference report the
+ * intake asks for.
+ */
+export interface ImportSpecModalProps {
+    kind: SpecImportKind;
+    /** The host's current project (only the workflow list key reads it). */
+    project: string | undefined;
+    /** The three list query keys, injected by the host. */
+    listKeys: SpecImportListKeys;
+    /** Navigate to the imported row; the modal closes itself first. */
+    onOpenImported: (kind: SpecImportKind, id: string) => void;
+    onClose: () => void;
+}
+export declare function ImportSpecModal(props: ImportSpecModalProps): import("react").JSX.Element;