@orthacms/webhooks-admin 0.5.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ortha CMS contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,7 @@
+# @orthacms/webhooks-admin
+
+Part of [Ortha CMS](https://github.com/ortha-source/ortha-cms).
+
+```sh
+npm install @orthacms/webhooks-admin
+```

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `@orthacms/webhooks-admin` — the global webhooks surface.
+ *
+ * Two pages in the sidebar's directory group: the endpoint list, and one
+ * endpoint with its settings and its delivery log. Both are administrator-only,
+ * because an endpoint is not scoped to a workspace and holds a signing secret.
+ */
+export { WebhooksPlugin, type WebhooksAdminPlugin } from './lib/utils/webhooksPlugin';
+export { useWebhookEndpoint, useWebhookEndpoints } from './lib/application/useWebhookEndpoints';
+export type { CreatedWebhookEndpoint, WebhookDelivery, WebhookDeliveryDetail, WebhookDeliveryPage, WebhookEndpoint, WebhookEventOption, WebhookLastDelivery, WebhookTestResult } from './lib/domain/types/webhook';
+export type { SaveWebhookInput, WebhookGateway } from './lib/infrastructure/webhookGateway';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACH,cAAc,EACd,KAAK,mBAAmB,EAC3B,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EACH,kBAAkB,EAClB,mBAAmB,EACtB,MAAM,uCAAuC,CAAC;AAE/C,YAAY,EACR,sBAAsB,EACtB,eAAe,EACf,qBAAqB,EACrB,mBAAmB,EACnB,eAAe,EACf,kBAAkB,EAClB,mBAAmB,EACnB,iBAAiB,EACpB,MAAM,4BAA4B,CAAC;AAEpC,YAAY,EACR,gBAAgB,EAChB,cAAc,EACjB,MAAM,qCAAqC,CAAC"}

package/dist/index.js

@@ -0,0 +1,9 @@
+/**
+ * `@orthacms/webhooks-admin` — the global webhooks surface.
+ *
+ * Two pages in the sidebar's directory group: the endpoint list, and one
+ * endpoint with its settings and its delivery log. Both are administrator-only,
+ * because an endpoint is not scoped to a workspace and holds a signing secret.
+ */
+export { WebhooksPlugin } from './lib/utils/webhooksPlugin';
+export { useWebhookEndpoint, useWebhookEndpoints } from './lib/application/useWebhookEndpoints';

package/dist/lib/application/useContentTypeOptions/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The code-defined content types, for the endpoint editor's type picker.
+ *
+ * Two things make this query unlike the others here.
+ *
+ * It reads content's registry (`GET /api/content-schema`), which is gated on
+ * `content:read` rather than on a webhooks permission. Every administrator
+ * holds it, so in practice it is there — but a deployment is free to define a
+ * role that manages webhooks without reading content, and a **403 is answered
+ * with an empty catalogue rather than an error**: the picker is a convenience
+ * over a free-text filter, and typing a machine name still works with no
+ * catalogue at all. Any other failure is a real failure and still throws.
+ *
+ * Like the other pickers it only exists inside a dialog, so the caller passes
+ * `enabled` and nothing is fetched before the dialog opens.
+ */
+export declare function useContentTypeOptions(enabled?: boolean): import("@tanstack/react-query").UseQueryResult<NoInfer<import("../../domain/types/contentTypeOption").ContentTypeOption[]>, Error>;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/application/useContentTypeOptions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/application/useContentTypeOptions/index.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,UAAO,sIAgBnD"}

package/dist/lib/application/useContentTypeOptions/index.js

@@ -0,0 +1,40 @@
+import { useQuery } from '@tanstack/react-query';
+import { ApiError } from '@orthacms/utils-admin';
+import { httpWebhookGateway } from '../../infrastructure/httpWebhookGateway';
+import { webhooksKeys } from '../../infrastructure/webhooksKeys';
+/** How long the type catalogue is treated as fresh inside the editor. */
+const OPTIONS_STALE_TIME_MS = 60_000;
+/**
+ * The code-defined content types, for the endpoint editor's type picker.
+ *
+ * Two things make this query unlike the others here.
+ *
+ * It reads content's registry (`GET /api/content-schema`), which is gated on
+ * `content:read` rather than on a webhooks permission. Every administrator
+ * holds it, so in practice it is there — but a deployment is free to define a
+ * role that manages webhooks without reading content, and a **403 is answered
+ * with an empty catalogue rather than an error**: the picker is a convenience
+ * over a free-text filter, and typing a machine name still works with no
+ * catalogue at all. Any other failure is a real failure and still throws.
+ *
+ * Like the other pickers it only exists inside a dialog, so the caller passes
+ * `enabled` and nothing is fetched before the dialog opens.
+ */
+export function useContentTypeOptions(enabled = true) {
+    return useQuery({
+        queryKey: webhooksKeys.contentTypes(),
+        queryFn: async () => {
+            try {
+                return await httpWebhookGateway.listContentTypeOptions();
+            }
+            catch (error) {
+                if (error instanceof ApiError && error.status === 403) {
+                    return [];
+                }
+                throw error;
+            }
+        },
+        staleTime: OPTIONS_STALE_TIME_MS,
+        enabled
+    });
+}

package/dist/lib/application/useWebhookDeliveries/index.d.ts

@@ -0,0 +1,19 @@
+import { type DeliveriesListParams } from '../../infrastructure/webhooksKeys';
+/** Rows per page in the delivery log. */
+export declare const DEFAULT_PAGE_SIZE = 25;
+/**
+ * One page of an endpoint's delivery log.
+ *
+ * It **polls while anything is unfinished** and stops when nothing is: a
+ * delivery that is queued or waiting for its retry changes state without
+ * anybody pressing anything, and a log that needs a manual refresh to show that
+ * is a log people stop trusting. Once every row is terminal there is nothing
+ * left to watch, so the polling stops rather than running for as long as the
+ * tab is open.
+ *
+ * `keepPreviousData` avoids the page blanking between pages and between polls.
+ */
+export declare function useWebhookDeliveries(endpointId: string, params: DeliveriesListParams, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<NoInfer<import("../../..").WebhookDeliveryPage>, Error>;
+/** One delivery with its request and response bodies, for the detail panel. */
+export declare function useWebhookDelivery(endpointId: string, deliveryId: string | null): import("@tanstack/react-query").UseQueryResult<NoInfer<import("../../..").WebhookDeliveryDetail>, Error>;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/application/useWebhookDeliveries/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/application/useWebhookDeliveries/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAEH,KAAK,oBAAoB,EAC5B,MAAM,mCAAmC,CAAC;AAE3C,yCAAyC;AACzC,eAAO,MAAM,iBAAiB,KAAK,CAAC;AAKpC;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAChC,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,oBAAoB,EAC5B,OAAO,UAAO,0GAmBjB;AAED,+EAA+E;AAC/E,wBAAgB,kBAAkB,CAC9B,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GAAG,IAAI,4GAY5B"}

package/dist/lib/application/useWebhookDeliveries/index.js

@@ -0,0 +1,48 @@
+import { keepPreviousData, useQuery } from '@tanstack/react-query';
+import { httpWebhookGateway } from '../../infrastructure/httpWebhookGateway';
+import { webhooksKeys } from '../../infrastructure/webhooksKeys';
+/** Rows per page in the delivery log. */
+export const DEFAULT_PAGE_SIZE = 25;
+/** How often the log refreshes while something in it is still in flight. */
+const IN_FLIGHT_POLL_MS = 3_000;
+/**
+ * One page of an endpoint's delivery log.
+ *
+ * It **polls while anything is unfinished** and stops when nothing is: a
+ * delivery that is queued or waiting for its retry changes state without
+ * anybody pressing anything, and a log that needs a manual refresh to show that
+ * is a log people stop trusting. Once every row is terminal there is nothing
+ * left to watch, so the polling stops rather than running for as long as the
+ * tab is open.
+ *
+ * `keepPreviousData` avoids the page blanking between pages and between polls.
+ */
+export function useWebhookDeliveries(endpointId, params, enabled = true) {
+    return useQuery({
+        queryKey: webhooksKeys.deliveries(endpointId, params),
+        queryFn: () => httpWebhookGateway.listDeliveries(endpointId, params),
+        placeholderData: keepPreviousData,
+        refetchInterval: (query) => {
+            const page = query.state.data;
+            if (!page)
+                return false;
+            const inFlight = page.items.some((delivery) => delivery.status === 'pending' ||
+                delivery.status === 'delivering' ||
+                delivery.status === 'failed');
+            return inFlight ? IN_FLIGHT_POLL_MS : false;
+        },
+        enabled
+    });
+}
+/** One delivery with its request and response bodies, for the detail panel. */
+export function useWebhookDelivery(endpointId, deliveryId) {
+    return useQuery({
+        queryKey: [
+            ...webhooksKeys.deliveriesOf(endpointId),
+            'detail',
+            deliveryId
+        ],
+        queryFn: () => httpWebhookGateway.getDelivery(endpointId, deliveryId),
+        enabled: deliveryId !== null
+    });
+}

package/dist/lib/application/useWebhookEndpoints/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Every configured endpoint.
+ *
+ * Not paginated: this is deployment configuration, and an installation with
+ * enough endpoints to need pages has a different problem. `enabled` is how the
+ * caller withholds the request until `webhooks:read` is confirmed, so an
+ * unauthorized page never fires a request the server would 403.
+ */
+export declare function useWebhookEndpoints(enabled?: boolean): import("@tanstack/react-query").UseQueryResult<NoInfer<import("../../..").WebhookEndpoint[]>, Error>;
+/** One endpoint, for the detail page. */
+export declare function useWebhookEndpoint(id: string, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<NoInfer<import("../../..").WebhookEndpoint>, Error>;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/application/useWebhookEndpoints/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/application/useWebhookEndpoints/index.ts"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,UAAO,wGAMjD;AAED,yCAAyC;AACzC,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,UAAO,sGAM5D"}

package/dist/lib/application/useWebhookEndpoints/index.js

@@ -0,0 +1,26 @@
+import { useQuery } from '@tanstack/react-query';
+import { httpWebhookGateway } from '../../infrastructure/httpWebhookGateway';
+import { webhooksKeys } from '../../infrastructure/webhooksKeys';
+/**
+ * Every configured endpoint.
+ *
+ * Not paginated: this is deployment configuration, and an installation with
+ * enough endpoints to need pages has a different problem. `enabled` is how the
+ * caller withholds the request until `webhooks:read` is confirmed, so an
+ * unauthorized page never fires a request the server would 403.
+ */
+export function useWebhookEndpoints(enabled = true) {
+    return useQuery({
+        queryKey: webhooksKeys.list(),
+        queryFn: () => httpWebhookGateway.list(),
+        enabled
+    });
+}
+/** One endpoint, for the detail page. */
+export function useWebhookEndpoint(id, enabled = true) {
+    return useQuery({
+        queryKey: webhooksKeys.detail(id),
+        queryFn: () => httpWebhookGateway.get(id),
+        enabled
+    });
+}

package/dist/lib/application/useWebhookEvents/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The subscribable event catalogue.
+ *
+ * Served by the API rather than compiled into the SPA, so an admin running
+ * against a newer server offers the kinds that server actually knows about —
+ * the same reason the content-type picker reads `/content-schema`.
+ */
+export declare function useWebhookEvents(enabled?: boolean): import("@tanstack/react-query").UseQueryResult<NoInfer<import("../../..").WebhookEventOption[]>, Error>;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/application/useWebhookEvents/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/application/useWebhookEvents/index.ts"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,UAAO,2GAO9C"}

package/dist/lib/application/useWebhookEvents/index.js

@@ -0,0 +1,20 @@
+import { useQuery } from '@tanstack/react-query';
+import { httpWebhookGateway } from '../../infrastructure/httpWebhookGateway';
+import { webhooksKeys } from '../../infrastructure/webhooksKeys';
+/** How long the catalogue is treated as fresh — it changes on deploy, not in use. */
+const CATALOGUE_STALE_TIME_MS = 5 * 60_000;
+/**
+ * The subscribable event catalogue.
+ *
+ * Served by the API rather than compiled into the SPA, so an admin running
+ * against a newer server offers the kinds that server actually knows about —
+ * the same reason the content-type picker reads `/content-schema`.
+ */
+export function useWebhookEvents(enabled = true) {
+    return useQuery({
+        queryKey: webhooksKeys.events(),
+        queryFn: () => httpWebhookGateway.listEvents(),
+        staleTime: CATALOGUE_STALE_TIME_MS,
+        enabled
+    });
+}

package/dist/lib/application/useWebhookMutations/index.d.ts

@@ -0,0 +1,25 @@
+import type { SaveWebhookInput } from '../../infrastructure/webhookGateway';
+/** Creates an endpoint; the result carries the one-time signing secret. */
+export declare function useCreateWebhook(): import("@tanstack/react-query").UseMutationResult<import("../../..").CreatedWebhookEndpoint, Error, SaveWebhookInput, unknown>;
+/** Updates an endpoint's configuration. */
+export declare function useUpdateWebhook(): import("@tanstack/react-query").UseMutationResult<import("../../..").WebhookEndpoint, Error, {
+    id: string;
+    input: SaveWebhookInput;
+}, unknown>;
+/** Deletes an endpoint and, with it, its delivery log. */
+export declare function useDeleteWebhook(): import("@tanstack/react-query").UseMutationResult<void, Error, string, unknown>;
+/** Mints a new signing secret and returns it once. */
+export declare function useRotateWebhookSecret(): import("@tanstack/react-query").UseMutationResult<import("../../..").CreatedWebhookEndpoint, Error, string, unknown>;
+/**
+ * Sends a test ping.
+ *
+ * Nothing is invalidated: a test is not queued and never becomes a log row, so
+ * there is no cached state it could have changed.
+ */
+export declare function useTestWebhook(): import("@tanstack/react-query").UseMutationResult<import("../../..").WebhookTestResult, Error, string, unknown>;
+/** Queues an already-sent delivery again. */
+export declare function useRedeliverWebhook(): import("@tanstack/react-query").UseMutationResult<import("../../..").WebhookDelivery, Error, {
+    endpointId: string;
+    deliveryId: string;
+}, unknown>;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/application/useWebhookMutations/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/application/useWebhookMutations/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qCAAqC,CAAC;AAE5E,2EAA2E;AAC3E,wBAAgB,gBAAgB,mIAS/B;AAED,2CAA2C;AAC3C,wBAAgB,gBAAgB;QAGU,MAAM;WAAS,gBAAgB;YAaxE;AAED,0DAA0D;AAC1D,wBAAgB,gBAAgB,oFAY/B;AAED,sDAAsD;AACtD,wBAAgB,sBAAsB,yHAYrC;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,oHAI7B;AAED,6CAA6C;AAC7C,wBAAgB,mBAAmB;gBAOX,MAAM;gBACN,MAAM;YAY7B"}

package/dist/lib/application/useWebhookMutations/index.js

@@ -0,0 +1,79 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { httpWebhookGateway } from '../../infrastructure/httpWebhookGateway';
+import { webhooksKeys } from '../../infrastructure/webhooksKeys';
+/** Creates an endpoint; the result carries the one-time signing secret. */
+export function useCreateWebhook() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (input) => httpWebhookGateway.create(input),
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: webhooksKeys.list() });
+        }
+    });
+}
+/** Updates an endpoint's configuration. */
+export function useUpdateWebhook() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: ({ id, input }) => httpWebhookGateway.update(id, input),
+        onSuccess: (endpoint) => {
+            // The response is the updated row, so the detail page can be
+            // written directly rather than refetched; the list still needs
+            // invalidating because the change may reorder or re-badge it.
+            queryClient.setQueryData(webhooksKeys.detail(endpoint.id), endpoint);
+            queryClient.invalidateQueries({ queryKey: webhooksKeys.list() });
+        }
+    });
+}
+/** Deletes an endpoint and, with it, its delivery log. */
+export function useDeleteWebhook() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (id) => httpWebhookGateway.remove(id),
+        onSuccess: (_result, id) => {
+            queryClient.removeQueries({ queryKey: webhooksKeys.detail(id) });
+            queryClient.removeQueries({
+                queryKey: webhooksKeys.deliveriesOf(id)
+            });
+            queryClient.invalidateQueries({ queryKey: webhooksKeys.list() });
+        }
+    });
+}
+/** Mints a new signing secret and returns it once. */
+export function useRotateWebhookSecret() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (id) => httpWebhookGateway.rotateSecret(id),
+        onSuccess: ({ endpoint }) => {
+            queryClient.setQueryData(webhooksKeys.detail(endpoint.id), endpoint);
+            queryClient.invalidateQueries({ queryKey: webhooksKeys.list() });
+        }
+    });
+}
+/**
+ * Sends a test ping.
+ *
+ * Nothing is invalidated: a test is not queued and never becomes a log row, so
+ * there is no cached state it could have changed.
+ */
+export function useTestWebhook() {
+    return useMutation({
+        mutationFn: (id) => httpWebhookGateway.test(id)
+    });
+}
+/** Queues an already-sent delivery again. */
+export function useRedeliverWebhook() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: ({ endpointId, deliveryId }) => httpWebhookGateway.redeliver(endpointId, deliveryId),
+        onSuccess: (_delivery, { endpointId }) => {
+            // Scoped to this endpoint's log rather than the whole root: the log
+            // is polled, and invalidating everything would refetch every other
+            // endpoint's pages for a change that cannot affect them.
+            queryClient.invalidateQueries({
+                queryKey: webhooksKeys.deliveriesOf(endpointId)
+            });
+            queryClient.invalidateQueries({ queryKey: webhooksKeys.list() });
+        }
+    });
+}

package/dist/lib/application/useWorkspaceOptions/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Every workspace, for the endpoint editor's picker.
+ *
+ * Requires `workspaces:read`, which every role holds — but the caller still
+ * passes `enabled`, because the picker only exists inside a dialog and there is
+ * no reason to fetch before it opens.
+ */
+export declare function useWorkspaceOptions(enabled?: boolean): import("@tanstack/react-query").UseQueryResult<NoInfer<import("../../domain/types/workspaceOption").WorkspaceOption[]>, Error>;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/application/useWorkspaceOptions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/application/useWorkspaceOptions/index.ts"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,UAAO,kIAOjD"}

package/dist/lib/application/useWorkspaceOptions/index.js

@@ -0,0 +1,19 @@
+import { useQuery } from '@tanstack/react-query';
+import { httpWebhookGateway } from '../../infrastructure/httpWebhookGateway';
+/** How long the workspace list is treated as fresh inside the editor. */
+const OPTIONS_STALE_TIME_MS = 60_000;
+/**
+ * Every workspace, for the endpoint editor's picker.
+ *
+ * Requires `workspaces:read`, which every role holds — but the caller still
+ * passes `enabled`, because the picker only exists inside a dialog and there is
+ * no reason to fetch before it opens.
+ */
+export function useWorkspaceOptions(enabled = true) {
+    return useQuery({
+        queryKey: ['webhooks', 'workspace-options'],
+        queryFn: () => httpWebhookGateway.listWorkspaceOptions(),
+        staleTime: OPTIONS_STALE_TIME_MS,
+        enabled
+    });
+}

package/dist/lib/domain/contentTypeChoices/index.d.ts

@@ -0,0 +1,65 @@
+import type { ContentTypeOption } from '../types/contentTypeOption';
+import type { WorkspaceOption } from '../types/workspaceOption';
+/**
+ * One row of the content-type picker.
+ *
+ * `known` is the whole point of this module: a subscription may name a type the
+ * running build does not define — one that is about to be added, or one that
+ * was removed, or a typo. Such a name must stay selectable and must survive a
+ * save, but it should not look like the types the registry vouches for.
+ */
+export type ContentTypeChoice = {
+    /** The machine name — what travels on the wire. */
+    value: string;
+    /** The registry's label, or the name itself when it has none. */
+    label: string;
+    /** Whether this build defines the type. */
+    known: boolean;
+};
+/**
+ * The picker's options: the registry's types, plus any already-selected name it
+ * does not know, appended in selection order.
+ *
+ * Dropping the unknown ones would be the worst possible behaviour here — the
+ * picker would render a subscription it cannot express, and the next save would
+ * silently widen the endpoint to types it was deliberately narrowed away from.
+ */
+export declare function contentTypeChoices(catalogue: readonly ContentTypeOption[], selected: readonly string[]): ContentTypeChoice[];
+/**
+ * Reads typed-in machine names.
+ *
+ * Commas, whitespace and newlines all separate, because this field is pasted
+ * into as often as it is typed into, and `article, product` is what a paste
+ * looks like. The server accepts any string here — it must, or a type that does
+ * not exist yet could never be subscribed to — so this only trims and splits;
+ * it does not decide what a valid type name looks like.
+ */
+export declare function parseContentTypeNames(raw: string): string[];
+/** Appends `names` to `selected`, keeping order and dropping duplicates. */
+export declare function addContentTypeNames(selected: readonly string[], names: readonly string[]): string[];
+/** The endpoint's workspace filter, as the form holds it. */
+export type WorkspaceSelection = {
+    /** Every workspace, including ones created later. */
+    allWorkspaces: boolean;
+    /** The chosen workspace ids, when `allWorkspaces` is off. */
+    workspaceIds: readonly string[];
+};
+/**
+ * The types worth offering for a given workspace filter.
+ *
+ * A delivery needs both halves of the filter to match — the event's workspace
+ * **and** its content type — so a type none of the chosen workspaces was granted
+ * can never fire for this endpoint. Offering it is offering a filter that
+ * guarantees silence, which is the mistake the editor exists to prevent.
+ *
+ * Two cases deliberately fall back to the whole registry rather than to
+ * nothing:
+ *
+ * - **`allWorkspaces`** — the endpoint covers workspaces that do not exist yet,
+ *   and those may be granted anything.
+ * - **no workspace chosen at all** — there is nothing to narrow by. The caller
+ *   decides whether to show the picker at all in that state; narrowing to an
+ *   empty list here would be a guess dressed up as a rule.
+ */
+export declare function grantedContentTypes(catalogue: readonly ContentTypeOption[], workspaces: readonly WorkspaceOption[], { allWorkspaces, workspaceIds }: WorkspaceSelection): ContentTypeOption[];
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/domain/contentTypeChoices/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/domain/contentTypeChoices/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AACpE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAEhE;;;;;;;GAOG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC5B,mDAAmD;IACnD,KAAK,EAAE,MAAM,CAAC;IACd,iEAAiE;IACjE,KAAK,EAAE,MAAM,CAAC;IACd,2CAA2C;IAC3C,KAAK,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAC9B,SAAS,EAAE,SAAS,iBAAiB,EAAE,EACvC,QAAQ,EAAE,SAAS,MAAM,EAAE,GAC5B,iBAAiB,EAAE,CAYrB;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAK3D;AAED,4EAA4E;AAC5E,wBAAgB,mBAAmB,CAC/B,QAAQ,EAAE,SAAS,MAAM,EAAE,EAC3B,KAAK,EAAE,SAAS,MAAM,EAAE,GACzB,MAAM,EAAE,CAMV;AAED,6DAA6D;AAC7D,MAAM,MAAM,kBAAkB,GAAG;IAC7B,qDAAqD;IACrD,aAAa,EAAE,OAAO,CAAC;IACvB,6DAA6D;IAC7D,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,mBAAmB,CAC/B,SAAS,EAAE,SAAS,iBAAiB,EAAE,EACvC,UAAU,EAAE,SAAS,eAAe,EAAE,EACtC,EAAE,aAAa,EAAE,YAAY,EAAE,EAAE,kBAAkB,GACpD,iBAAiB,EAAE,CASrB"}

package/dist/lib/domain/contentTypeChoices/index.js

@@ -0,0 +1,70 @@
+/**
+ * The picker's options: the registry's types, plus any already-selected name it
+ * does not know, appended in selection order.
+ *
+ * Dropping the unknown ones would be the worst possible behaviour here — the
+ * picker would render a subscription it cannot express, and the next save would
+ * silently widen the endpoint to types it was deliberately narrowed away from.
+ */
+export function contentTypeChoices(catalogue, selected) {
+    const known = new Set(catalogue.map((type) => type.name));
+    return [
+        ...catalogue.map((type) => ({
+            value: type.name,
+            label: type.label,
+            known: true
+        })),
+        ...selected
+            .filter((name) => !known.has(name))
+            .map((name) => ({ value: name, label: name, known: false }))
+    ];
+}
+/**
+ * Reads typed-in machine names.
+ *
+ * Commas, whitespace and newlines all separate, because this field is pasted
+ * into as often as it is typed into, and `article, product` is what a paste
+ * looks like. The server accepts any string here — it must, or a type that does
+ * not exist yet could never be subscribed to — so this only trims and splits;
+ * it does not decide what a valid type name looks like.
+ */
+export function parseContentTypeNames(raw) {
+    return raw
+        .split(/[\s,]+/)
+        .map((name) => name.trim())
+        .filter(Boolean);
+}
+/** Appends `names` to `selected`, keeping order and dropping duplicates. */
+export function addContentTypeNames(selected, names) {
+    const next = [...selected];
+    for (const name of names) {
+        if (!next.includes(name))
+            next.push(name);
+    }
+    return next;
+}
+/**
+ * The types worth offering for a given workspace filter.
+ *
+ * A delivery needs both halves of the filter to match — the event's workspace
+ * **and** its content type — so a type none of the chosen workspaces was granted
+ * can never fire for this endpoint. Offering it is offering a filter that
+ * guarantees silence, which is the mistake the editor exists to prevent.
+ *
+ * Two cases deliberately fall back to the whole registry rather than to
+ * nothing:
+ *
+ * - **`allWorkspaces`** — the endpoint covers workspaces that do not exist yet,
+ *   and those may be granted anything.
+ * - **no workspace chosen at all** — there is nothing to narrow by. The caller
+ *   decides whether to show the picker at all in that state; narrowing to an
+ *   empty list here would be a guess dressed up as a rule.
+ */
+export function grantedContentTypes(catalogue, workspaces, { allWorkspaces, workspaceIds }) {
+    if (allWorkspaces || workspaceIds.length === 0)
+        return [...catalogue];
+    const granted = new Set(workspaces
+        .filter((workspace) => workspaceIds.includes(workspace.id))
+        .flatMap((workspace) => workspace.contentTypes));
+    return catalogue.filter((type) => granted.has(type.name));
+}

package/dist/lib/domain/headerRules/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Which custom headers an endpoint may set.
+ *
+ * A **deliberate copy** of `@orthacms/webhooks-domain`'s `isAllowedCustomHeader`
+ * rather than an import: that package's barrel reaches `node:crypto` through
+ * the signature helpers, and pulling it into the browser bundle takes the whole
+ * admin down at load. The server enforces the same rule on every write — this
+ * copy only turns a `422` into an error beside the field that caused it.
+ */
+/** Why a header name was refused, or `null` when it is fine. */
+export type HeaderRejection = 'malformed' | 'reserved';
+/**
+ * Checks one header name.
+ *
+ * Overwriting `X-Ortha-Signature` or `X-Ortha-Event` would let a delivery claim
+ * to be something it is not, and `Host` is how a request aimed at one virtual
+ * host gets served by another — so both are refused rather than silently
+ * dropped at send time.
+ */
+export declare function rejectionFor(name: string): HeaderRejection | null;
+/** One row of the headers editor. A row keeps its identity while it is edited. */
+export type HeaderRow = {
+    key: string;
+    name: string;
+    value: string;
+};
+/** Turns the stored map into rows, in a stable order. */
+export declare function toHeaderRows(headers: Record<string, string>): HeaderRow[];
+/**
+ * Turns rows back into the map the API takes.
+ *
+ * Blank rows are dropped — an editor that has one empty row open is not
+ * expressing "send an empty header" — and a later row of the same name wins,
+ * because that is what the map would have done anyway.
+ */
+export declare function fromHeaderRows(rows: readonly HeaderRow[]): Record<string, string>;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/domain/headerRules/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/domain/headerRules/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAkBH,gEAAgE;AAChE,MAAM,MAAM,eAAe,GAAG,WAAW,GAAG,UAAU,CAAC;AAEvD;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAQjE;AAED,kFAAkF;AAClF,MAAM,MAAM,SAAS,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAErE,yDAAyD;AACzD,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,EAAE,CAMzE;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC1B,IAAI,EAAE,SAAS,SAAS,EAAE,GAC3B,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAQxB"}