@cosmicdrift/kumiko-bundled-features 0.392.2 → 0.394.0

package/dist/inbound-provider-imap/screens.d.ts

@@ -1,2 +1,7 @@
+import { type InboundMailRoles } from "@cosmicdrift/kumiko-bundled-features/inbound-mail-foundation";
 import type { ActionFormScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
-export declare const imapConnectScreen: ActionFormScreenDefinition;
+export declare const createImapConnectScreen: ({ adminRoles, }: InboundMailRoles) => ActionFormScreenDefinition;
+export declare const createMyImapConnectScreen: ({ memberRoles, }: InboundMailRoles) => ActionFormScreenDefinition;
+export declare const createImapReconnectScreen: ({ adminRoles, }: InboundMailRoles) => ActionFormScreenDefinition;
+export declare const createMyImapReconnectScreen: ({ memberRoles, }: InboundMailRoles) => ActionFormScreenDefinition;
+export declare const createImapScreens: (roles: InboundMailRoles) => ActionFormScreenDefinition[];

package/dist/inbound-provider-imap/screens.js

@@ -1,47 +1,180 @@
-import { IMAP_CONNECT_SCREEN_ID, MAIL_ACCOUNT_LIST_SCREEN_QN, } from "@cosmicdrift/kumiko-bundled-features/inbound-mail-foundation";
+import { IMAP_CONNECT_SCREEN_ID, IMAP_RECONNECT_SCREEN_ID, MAIL_ACCOUNT_LIST_SCREEN_QN, MY_IMAP_CONNECT_SCREEN_ID, MY_IMAP_RECONNECT_SCREEN_ID, MY_MAIL_ACCOUNT_LIST_SCREEN_QN, } from "@cosmicdrift/kumiko-bundled-features/inbound-mail-foundation";
 import { i18nKey } from "@cosmicdrift/kumiko-framework/engine";
-import { ImapHandlers, SMTP_SUBMISSION_PORT } from "./constants.js";
+import { ImapHandlers, ImapQueries, SMTP_SUBMISSION_PORT } from "./constants.js";
+// The admin form connects a shared mailbox, the member form a personal one. The member form carries
+// no sender-check field because that policy is tenant-wide and only admins set it.
+function createConnectScreen(variant) {
+    return {
+        id: variant.id,
+        type: "actionForm",
+        agent: { expose: false },
+        handler: variant.handler,
+        fields: {
+            displayName: { type: "text", required: true, maxLength: 200 },
+            address: { type: "text", required: true, maxLength: 320, format: "email" },
+            host: { type: "text", required: true, maxLength: 255 },
+            port: {
+                type: "number",
+                integer: true,
+                grouping: false,
+                required: true,
+                min: 1,
+                max: 65535,
+                default: 993,
+            },
+            user: { type: "text", required: true, maxLength: 320 },
+            password: { type: "text", required: true, format: "password", sensitive: true },
+            smtpHost: { type: "text", maxLength: 255 },
+            smtpPort: {
+                type: "number",
+                integer: true,
+                grouping: false,
+                required: true,
+                min: 1,
+                max: 65535,
+                default: SMTP_SUBMISSION_PORT,
+            },
+            ...(variant.withSenderCheck && { trustedAuthservId: { type: "text", maxLength: 255 } }),
+        },
+        layout: {
+            sections: [
+                // The name-based icon guess reads "address" as a postal address.
+                { fields: ["displayName", { field: "address", icon: "mail" }] },
+                {
+                    title: i18nKey("inboundMail.imap.connect.server"),
+                    fields: ["host", "port", "user", "password"],
+                },
+                {
+                    title: i18nKey("inboundMail.imap.connect.outgoing"),
+                    description: i18nKey("inboundMail.imap.connect.outgoingHint"),
+                    fields: ["smtpHost", "smtpPort"],
+                },
+                ...(variant.withSenderCheck
+                    ? [
+                        {
+                            title: i18nKey("inboundMail.imap.connect.senderCheck"),
+                            description: i18nKey("inboundMail.imap.connect.senderCheckHint"),
+                            fields: ["trustedAuthservId"],
+                        },
+                    ]
+                    : []),
+            ],
+        },
+        submitLabel: i18nKey("inboundMail.imap.connect.submit"),
+        redirect: variant.returnTarget,
+        cancelTarget: variant.returnTarget,
+        access: { roles: [...variant.roles] },
+        dormant: true,
+    };
+}
 // Reached from the toolbar of the foundation's mail account list, never from the nav.
-export const imapConnectScreen = {
+export const createImapConnectScreen = ({ adminRoles, }) => createConnectScreen({
     id: IMAP_CONNECT_SCREEN_ID,
-    type: "actionForm",
-    agent: { expose: false },
     handler: ImapHandlers.connectMailbox,
-    fields: {
-        displayName: { type: "text", required: true, maxLength: 200 },
-        address: { type: "text", required: true, maxLength: 320, format: "email" },
-        host: { type: "text", required: true, maxLength: 255 },
-        port: { type: "number", integer: true, required: true, min: 1, max: 65535, default: 993 },
-        user: { type: "text", required: true, maxLength: 320 },
-        password: { type: "text", required: true, format: "password", sensitive: true },
-        smtpHost: { type: "text", maxLength: 255 },
-        smtpPort: {
-            type: "number",
-            integer: true,
-            required: true,
-            min: 1,
-            max: 65535,
-            default: SMTP_SUBMISSION_PORT,
-        },
-    },
-    layout: {
-        sections: [
-            // The name-based icon guess reads "address" as a postal address.
-            { fields: ["displayName", { field: "address", icon: "mail" }] },
-            {
-                title: i18nKey("inboundMail.imap.connect.server"),
-                fields: ["host", "port", "user", "password"],
+    roles: adminRoles,
+    returnTarget: MAIL_ACCOUNT_LIST_SCREEN_QN,
+    withSenderCheck: true,
+});
+// Reached from the toolbar of "My mail accounts".
+export const createMyImapConnectScreen = ({ memberRoles, }) => createConnectScreen({
+    id: MY_IMAP_CONNECT_SCREEN_ID,
+    handler: ImapHandlers.connectMyMailbox,
+    roles: memberRoles,
+    returnTarget: MY_MAIL_ACCOUNT_LIST_SCREEN_QN,
+    withSenderCheck: false,
+});
+// Reached from the "Reconnect" row action of an account with a sign-in error. The record id comes
+// from the path; the load query returns the stored server settings, never the password.
+// The admin and the owner variant share this form; the owner's carries no sender-check field
+// because that policy is tenant-wide and only admins set it.
+function createReconnectScreen(variant) {
+    return {
+        id: variant.id,
+        type: "actionForm",
+        agent: { expose: false },
+        handler: ImapHandlers.reconnectMailbox,
+        load: { query: ImapQueries.reconnectPrefill, idParam: "accountId" },
+        fields: {
+            accountId: { type: "text", required: true },
+            displayName: { type: "text", maxLength: 200 },
+            host: { type: "text", required: true, maxLength: 255 },
+            port: {
+                type: "number",
+                integer: true,
+                grouping: false,
+                required: true,
+                min: 1,
+                max: 65535,
+                default: 993,
             },
-            {
-                title: i18nKey("inboundMail.imap.connect.outgoing"),
-                description: i18nKey("inboundMail.imap.connect.outgoingHint"),
-                fields: ["smtpHost", "smtpPort"],
+            user: { type: "text", required: true, maxLength: 320 },
+            password: { type: "text", required: true, format: "password", sensitive: true },
+            smtpHost: { type: "text", maxLength: 255 },
+            smtpPort: {
+                type: "number",
+                integer: true,
+                grouping: false,
+                required: true,
+                min: 1,
+                max: 65535,
+                default: SMTP_SUBMISSION_PORT,
             },
-        ],
-    },
-    submitLabel: i18nKey("inboundMail.imap.connect.submit"),
-    redirect: MAIL_ACCOUNT_LIST_SCREEN_QN,
-    cancelTarget: MAIL_ACCOUNT_LIST_SCREEN_QN,
-    access: { roles: ["SystemAdmin", "TenantAdmin"] },
-    dormant: true,
-};
+            ...(variant.withSenderCheck && { trustedAuthservId: { type: "text", maxLength: 255 } }),
+        },
+        layout: {
+            sections: [
+                {
+                    title: i18nKey("inboundMail.imap.connect.server"),
+                    description: i18nKey("inboundMail.imap.reconnect.hint"),
+                    // The id only travels in the payload; the user recognises the mailbox by its name.
+                    fields: [
+                        { field: "accountId", visible: false },
+                        { field: "displayName", readOnly: true, submit: false },
+                        "host",
+                        "port",
+                        "user",
+                        "password",
+                    ],
+                },
+                {
+                    title: i18nKey("inboundMail.imap.connect.outgoing"),
+                    description: i18nKey("inboundMail.imap.connect.outgoingHint"),
+                    fields: ["smtpHost", "smtpPort"],
+                },
+                ...(variant.withSenderCheck
+                    ? [
+                        {
+                            title: i18nKey("inboundMail.imap.connect.senderCheck"),
+                            description: i18nKey("inboundMail.imap.connect.senderCheckHint"),
+                            fields: ["trustedAuthservId"],
+                        },
+                    ]
+                    : []),
+            ],
+        },
+        submitLabel: i18nKey("inboundMail.imap.reconnect.submit"),
+        redirect: variant.returnTarget,
+        cancelTarget: variant.returnTarget,
+        access: { roles: [...variant.roles] },
+        dormant: true,
+    };
+}
+export const createImapReconnectScreen = ({ adminRoles, }) => createReconnectScreen({
+    id: IMAP_RECONNECT_SCREEN_ID,
+    roles: adminRoles,
+    returnTarget: MAIL_ACCOUNT_LIST_SCREEN_QN,
+    withSenderCheck: true,
+});
+// Reached from the "Reactivate" row action of "My mail accounts".
+export const createMyImapReconnectScreen = ({ memberRoles, }) => createReconnectScreen({
+    id: MY_IMAP_RECONNECT_SCREEN_ID,
+    roles: memberRoles,
+    returnTarget: MY_MAIL_ACCOUNT_LIST_SCREEN_QN,
+    withSenderCheck: false,
+});
+export const createImapScreens = (roles) => [
+    createImapConnectScreen(roles),
+    createImapReconnectScreen(roles),
+    createMyImapConnectScreen(roles),
+    createMyImapReconnectScreen(roles),
+];

package/dist/inbound-provider-imap/send-mail.d.ts

@@ -1,2 +1,2 @@
-import { type InboundMailContext, type MailAccountRecord, type OutboundMailMessage, type OutboundMailSent } from "@cosmicdrift/kumiko-bundled-features/inbound-mail-foundation";
-export declare function sendFromImapAccount(ctx: InboundMailContext, account: MailAccountRecord, message: OutboundMailMessage): Promise<OutboundMailSent>;
+import { type InboundMailContext, type MailAccountRecord, type OutboundAttachment, type OutboundMailMessage, type ProviderSentMail } from "@cosmicdrift/kumiko-bundled-features/inbound-mail-foundation";
+export declare function sendFromImapAccount(ctx: InboundMailContext, account: MailAccountRecord, message: OutboundMailMessage, attachments: readonly OutboundAttachment[]): Promise<ProviderSentMail>;

package/dist/inbound-provider-imap/send-mail.js

@@ -20,7 +20,7 @@ function toFoundationSendError(err) {
 function stripAngles(id) {
     return id.replace(/^<|>$/g, "");
 }
-export async function sendFromImapAccount(ctx, account, message) {
+export async function sendFromImapAccount(ctx, account, message, attachments) {
     const doc = await readCredentialDocument(ctx, account);
     if (!doc.smtpHost || !doc.password) {
         throw new MailSendNotConfiguredError(`${FEATURE_NAME}: account ${account.id} has no outgoing server stored`);
@@ -35,6 +35,13 @@ export async function sendFromImapAccount(ctx, account, message) {
         ...(message.html !== undefined && { html: message.html }),
         ...(message.inReplyTo && { inReplyTo: message.inReplyTo }),
         ...(message.references && { references: [...message.references] }),
+        ...(attachments.length > 0 && {
+            attachments: attachments.map((attachment) => ({
+                filename: attachment.fileName,
+                contentType: attachment.mimeType,
+                content: Buffer.from(attachment.data),
+            })),
+        }),
     }).compile();
     const raw = await mime.build();
     try {

package/dist/inbound-provider-imap/sender-auth-headers.d.ts

@@ -0,0 +1,3 @@
+import { type SenderAuthentication } from "@cosmicdrift/kumiko-bundled-features/inbound-mail-foundation";
+import type { ParsedMail } from "mailparser";
+export declare function senderAuthenticationOf(parsed: ParsedMail, trustedAuthservId: string | null): SenderAuthentication | null;

package/dist/inbound-provider-imap/sender-auth-headers.js

@@ -0,0 +1,18 @@
+import { fromDomainOf, parseSenderAuthentication, } from "@cosmicdrift/kumiko-bundled-features/inbound-mail-foundation";
+const HEADER_NAME = "authentication-results";
+// headerLines keeps every occurrence in file order, topmost first. Unlike `headers`, which merges
+// repeated headers, the order is what the trust rule depends on.
+function authenticationResultValues(parsed) {
+    return parsed.headerLines
+        .filter((header) => header.key === HEADER_NAME)
+        .map((header) => header.line.slice(header.line.indexOf(":") + 1));
+}
+// A From header with addresses of several domains cannot be bound to one DMARC verdict.
+function singleFromDomain(parsed) {
+    const domains = new Set((parsed.from?.value ?? []).map((address) => fromDomainOf(address.address ?? "")));
+    const [only] = domains;
+    return domains.size === 1 && only ? only : null;
+}
+export function senderAuthenticationOf(parsed, trustedAuthservId) {
+    return parseSenderAuthentication(authenticationResultValues(parsed), trustedAuthservId, singleFromDomain(parsed));
+}

package/dist/inbound-provider-inmemory/feature.d.ts

@@ -4,11 +4,24 @@ export declare const INMEMORY_PROVIDER_KEY = "inmemory";
  *  pushed immediately (IDLE simulation); the next fetch also returns it by
  *  cursor — the foundation's deduplication makes this idempotent. */
 export declare function seedInboundMessage(accountId: string, msg: RawInboundMessage): Promise<void>;
+/** Test helper: a mail the provider cannot parse; fetch reports it as rejected and moves on. */
+export declare function seedRejectedInboundMessage(accountId: string, providerMessageId: string): void;
+/** Test helper: the full version of a message that fetchContent serves later. */
+export declare function setInboundFullContent(accountId: string, msg: RawInboundMessage): void;
+/** Test helper: the provider message ids of every fetchContent call so far. */
+export declare function contentFetchesOf(accountId: string): readonly (readonly string[])[];
 /** Test helper: injects a one-shot error into the next fetch (e.g.
  *  InboundAuthError or InboundCursorInvalidError). */
 export declare function failNextFetchWith(accountId: string, err: unknown): void;
 /** Test helper: injects a one-shot error into the next verify. */
 export declare function failNextVerifyWith(accountId: string, err: unknown): void;
+/** Test helper: fetches of the account do not return until `release()`, whatever the abort signal
+ *  says, like a provider that ignores cancellation on a dead connection. */
+export declare function hangFetchesOf(accountId: string): {
+    readonly release: () => void;
+};
+/** Test helper: the abort signal the last fetch of the account received. */
+export declare function lastFetchSignalOf(accountId: string): AbortSignal | undefined;
 /** Test helper: every fetch reads this tenant secret first, like a real
  *  provider reads its stored credentials; a missing secret is an auth error. */
 export declare function requireCredentialSecretOnFetch(accountId: string, key: string): void;
@@ -17,6 +30,8 @@ export declare function requireCredentialSecretOnFetch(accountId: string, key: s
 export declare function emitWatchError(accountId: string, err: unknown): void;
 /** Test helper: reports whether an account currently has an active watch. */
 export declare function isWatching(accountId: string): boolean;
+/** Test helper: the trustedAuthservId of the account the last watch was started with. */
+export declare function watchedTrustedAuthservIdOf(accountId: string): string | null | undefined;
 /** Test-Helper: kompletter State-Reset (Test-Isolation — Mock-States
  *  nie zwischen Tests teilen). */
 export declare function resetInboundInMemory(): void;

package/dist/inbound-provider-inmemory/feature.js

@@ -21,9 +21,14 @@ function stateFor(accountId) {
     if (!state) {
         state = {
             log: [],
+            fullContent: new Map(),
+            contentFetches: [],
             watch: null,
+            watchedTrustedAuthservId: undefined,
             nextFetchError: null,
             nextVerifyError: null,
+            hangingFetch: null,
+            lastFetchSignal: undefined,
             credentialSecretKey: null,
         };
         accounts.set(accountId, state);
@@ -35,10 +40,22 @@ function stateFor(accountId) {
  *  cursor — the foundation's deduplication makes this idempotent. */
 export async function seedInboundMessage(accountId, msg) {
     const state = stateFor(accountId);
-    state.log.push(msg);
+    state.log.push({ message: msg });
     if (state.watch)
         await state.watch.onMessages([msg]);
 }
+/** Test helper: a mail the provider cannot parse; fetch reports it as rejected and moves on. */
+export function seedRejectedInboundMessage(accountId, providerMessageId) {
+    stateFor(accountId).log.push({ rejected: { providerMessageId, reason: "unparseable" } });
+}
+/** Test helper: the full version of a message that fetchContent serves later. */
+export function setInboundFullContent(accountId, msg) {
+    stateFor(accountId).fullContent.set(msg.providerMessageId, msg);
+}
+/** Test helper: the provider message ids of every fetchContent call so far. */
+export function contentFetchesOf(accountId) {
+    return stateFor(accountId).contentFetches;
+}
 /** Test helper: injects a one-shot error into the next fetch (e.g.
  *  InboundAuthError or InboundCursorInvalidError). */
 export function failNextFetchWith(accountId, err) {
@@ -48,6 +65,23 @@ export function failNextFetchWith(accountId, err) {
 export function failNextVerifyWith(accountId, err) {
     stateFor(accountId).nextVerifyError = err;
 }
+/** Test helper: fetches of the account do not return until `release()`, whatever the abort signal
+ *  says, like a provider that ignores cancellation on a dead connection. */
+export function hangFetchesOf(accountId) {
+    const state = stateFor(accountId);
+    const { promise, resolve } = Promise.withResolvers();
+    state.hangingFetch = promise;
+    return {
+        release: () => {
+            state.hangingFetch = null;
+            resolve();
+        },
+    };
+}
+/** Test helper: the abort signal the last fetch of the account received. */
+export function lastFetchSignalOf(accountId) {
+    return stateFor(accountId).lastFetchSignal;
+}
 /** Test helper: every fetch reads this tenant secret first, like a real
  *  provider reads its stored credentials; a missing secret is an auth error. */
 export function requireCredentialSecretOnFetch(accountId, key) {
@@ -73,6 +107,10 @@ export function emitWatchError(accountId, err) {
 export function isWatching(accountId) {
     return accounts.get(accountId)?.watch != null;
 }
+/** Test helper: the trustedAuthservId of the account the last watch was started with. */
+export function watchedTrustedAuthservIdOf(accountId) {
+    return accounts.get(accountId)?.watchedTrustedAuthservId;
+}
 /** Test-Helper: kompletter State-Reset (Test-Isolation — Mock-States
  *  nie zwischen Tests teilen). */
 export function resetInboundInMemory() {
@@ -96,6 +134,9 @@ export const inMemoryInboundMailPlugin = {
     },
     fetch: async (ctx, account, cursor, opts) => {
         const state = stateFor(account.id);
+        state.lastFetchSignal = opts.signal;
+        if (state.hangingFetch)
+            await state.hangingFetch;
         if (state.nextFetchError) {
             const err = state.nextFetchError;
             state.nextFetchError = null;
@@ -107,15 +148,29 @@ export const inMemoryInboundMailPlugin = {
         const offset = offsetOf(cursor);
         const slice = state.log.slice(offset, offset + opts.maxMessages);
         const nextOffset = offset + slice.length;
+        const rejected = slice.flatMap((entry) => ("rejected" in entry ? [entry.rejected] : []));
         return {
-            messages: slice,
+            messages: slice.flatMap((entry) => ("message" in entry ? [entry.message] : [])),
+            ...(rejected.length > 0 && { rejected }),
             nextCursor: { offset: nextOffset },
             hasMore: nextOffset < state.log.length,
         };
     },
+    fetchContent: async (_ctx, account, providerMessageIds) => {
+        const state = stateFor(account.id);
+        state.contentFetches.push([...providerMessageIds]);
+        const messages = providerMessageIds.flatMap((id) => state.fullContent.get(id) ?? []);
+        const found = new Set(messages.map((m) => m.providerMessageId));
+        return {
+            messages,
+            missing: providerMessageIds.filter((id) => !found.has(id)),
+            rejected: [],
+        };
+    },
     watch: async (_ctx, account, handlers) => {
         const state = stateFor(account.id);
         state.watch = handlers;
+        state.watchedTrustedAuthservId = account.trustedAuthservId ?? null;
         return async () => {
             if (state.watch === handlers)
                 state.watch = null;

package/dist/inbound-provider-inmemory/index.d.ts

@@ -1 +1 @@
-export { createInboundProviderInMemoryFeature, emitWatchError, failNextFetchWith, failNextVerifyWith, INMEMORY_PROVIDER_KEY, isWatching, requireCredentialSecretOnFetch, resetInboundInMemory, seedInboundMessage, } from "./feature.ts";
+export { contentFetchesOf, createInboundProviderInMemoryFeature, emitWatchError, failNextFetchWith, failNextVerifyWith, hangFetchesOf, INMEMORY_PROVIDER_KEY, isWatching, lastFetchSignalOf, requireCredentialSecretOnFetch, resetInboundInMemory, seedInboundMessage, seedRejectedInboundMessage, setInboundFullContent, watchedTrustedAuthservIdOf, } from "./feature.ts";

package/dist/inbound-provider-inmemory/index.js

@@ -1,2 +1,2 @@
 // Public API of the inbound-provider-inmemory bundled-feature.
-export { createInboundProviderInMemoryFeature, emitWatchError, failNextFetchWith, failNextVerifyWith, INMEMORY_PROVIDER_KEY, isWatching, requireCredentialSecretOnFetch, resetInboundInMemory, seedInboundMessage, } from "./feature.js";
+export { contentFetchesOf, createInboundProviderInMemoryFeature, emitWatchError, failNextFetchWith, failNextVerifyWith, hangFetchesOf, INMEMORY_PROVIDER_KEY, isWatching, lastFetchSignalOf, requireCredentialSecretOnFetch, resetInboundInMemory, seedInboundMessage, seedRejectedInboundMessage, setInboundFullContent, watchedTrustedAuthservIdOf, } from "./feature.js";

package/dist/jobs/handlers/consumer.write.d.ts

@@ -7,7 +7,7 @@ export declare const consumerRestartWrite: import("@cosmicdrift/kumiko-types/def
     instanceId: string;
     status: string;
     skippedEventId: string | null;
-}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined, undefined>;
 export declare const consumerSkipWrite: import("@cosmicdrift/kumiko-types/define-handler").WriteHandlerDefinition<string, z.ZodObject<{
     name: z.ZodString;
     instanceId: z.ZodString;
@@ -16,7 +16,7 @@ export declare const consumerSkipWrite: import("@cosmicdrift/kumiko-types/define
     instanceId: string;
     status: string;
     skippedEventId: string | null;
-}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined, undefined>;
 export declare const consumerDisableWrite: import("@cosmicdrift/kumiko-types/define-handler").WriteHandlerDefinition<string, z.ZodObject<{
     name: z.ZodString;
     instanceId: z.ZodString;
@@ -25,7 +25,7 @@ export declare const consumerDisableWrite: import("@cosmicdrift/kumiko-types/def
     instanceId: string;
     status: string;
     skippedEventId: string | null;
-}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined, undefined>;
 export declare const consumerEnableWrite: import("@cosmicdrift/kumiko-types/define-handler").WriteHandlerDefinition<string, z.ZodObject<{
     name: z.ZodString;
     instanceId: z.ZodString;
@@ -34,4 +34,4 @@ export declare const consumerEnableWrite: import("@cosmicdrift/kumiko-types/defi
     instanceId: string;
     status: string;
     skippedEventId: string | null;
-}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined, undefined>;

package/dist/jobs/handlers/retry.write.d.ts

@@ -5,4 +5,4 @@ export declare const retryWrite: import("@cosmicdrift/kumiko-types/define-handle
     jobName: string;
     bullJobId: string;
     retriedFromRunId: string;
-}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined, undefined>;

package/dist/jobs/handlers/trigger.write.d.ts

@@ -5,4 +5,4 @@ export declare const triggerWrite: import("@cosmicdrift/kumiko-types/define-hand
 }, z.core.$strip>, {
     jobName: string;
     bullJobId: string;
-}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined, undefined>;

package/dist/managed-pages/handlers/set.write.d.ts

@@ -12,4 +12,4 @@ export declare const setWrite: import("@cosmicdrift/kumiko-types/define-handler"
     slug: string;
     lang: string;
     isNew: boolean;
-}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined, undefined>;

package/dist/managed-pages/web/i18n.js

@@ -13,6 +13,7 @@ export const MANAGED_PAGES_I18N = {
     // Screen titles (global/unprefixed, screenTitleKey = screen:<id>.title)
     "screen:page-list.title": { en: "Pages" },
     "screen:page-edit.title": { en: "Edit page" },
+    "screen:page-edit.createTitle": { en: "New page" },
     "screen:branding-settings.title": { en: "Branding" },
     // Page-Entity Feld-Labels (managed-pages:entity:page:field:*)
     "managed-pages:entity:page:field:slug": { en: "Slug" },

package/dist/personal-access-tokens/handlers/create.write.d.ts

@@ -17,4 +17,4 @@ export declare function createPatCreateHandler(opts?: CreatePatOptions): import(
     id: string;
     token: string;
     prefix: string;
-}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined, undefined>;

package/dist/personal-access-tokens/handlers/revoke.write.d.ts

@@ -3,4 +3,4 @@ export declare const revokePatWrite: import("@cosmicdrift/kumiko-types/define-ha
     id: z.ZodUUID;
 }, z.core.$strip>, {
     id: string;
-}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined, undefined>;

package/dist/readiness/handlers/run-probes.write.d.ts

@@ -4,4 +4,4 @@ export declare const runProbesWrite: import("@cosmicdrift/kumiko-types/define-ha
 }, z.core.$strip>, {
     runId: string;
     isExisting: boolean;
-}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined, undefined>;

package/dist/secrets/handlers/delete.write.d.ts

@@ -4,4 +4,4 @@ export declare function createDeleteHandler(access?: AccessRule): import("@cosmi
     key: z.ZodString;
 }, z.core.$strip>, {
     key: string;
-}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined, undefined>;

package/dist/secrets/handlers/set.write.d.ts

@@ -8,4 +8,4 @@ export declare function createSetHandler(access?: AccessRule): import("@cosmicdr
 }, z.core.$strip>, {
     key: string;
     redactedPreview: string;
-}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined, undefined>;

package/dist/sessions/handlers/revoke-all-for-user.write.d.ts

@@ -6,4 +6,4 @@ export declare const revokeAllForUserWrite: import("@cosmicdrift/kumiko-types/de
 }, z.core.$strip>, {
     count: number;
     userId: string;
-}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined, undefined>;

package/dist/sessions/handlers/revoke-all-others.write.d.ts

@@ -1,4 +1,4 @@
 import * as z from "zod";
 export declare const revokeAllOthersWrite: import("@cosmicdrift/kumiko-types/define-handler").WriteHandlerDefinition<"user-session:revoke-all-others", z.ZodObject<{}, z.core.$strip>, {
     count: number;
-}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined, undefined>;

package/dist/sessions/handlers/revoke.write.d.ts

@@ -3,4 +3,4 @@ export declare const revokeWrite: import("@cosmicdrift/kumiko-types/define-handl
     id: z.ZodUUID;
 }, z.core.$strip>, {
     id: string;
-}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined, undefined>;

package/dist/subscription-paddle/checkout-config.query.d.ts

@@ -0,0 +1,3 @@
+import * as z from "zod";
+import type { PaddleRuntimes } from "./runtime.ts";
+export declare function makeCheckoutConfigQuery(readCheckoutConfig: PaddleRuntimes["readCheckoutConfig"]): import("@cosmicdrift/kumiko-types/define-handler").QueryHandlerDefinition<"checkout-config", z.ZodObject<{}, z.core.$strip>, import("./runtime.ts").PaddleCheckoutConfig, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;

package/dist/subscription-paddle/checkout-config.query.js

@@ -0,0 +1,14 @@
+import { defineQueryHandler } from "@cosmicdrift/kumiko-framework/engine";
+import * as z from "zod";
+// Anonymous on purpose: the checkout page is public. The answer is the public
+// Paddle.js client token and the environment, nothing else.
+export function makeCheckoutConfigQuery(readCheckoutConfig) {
+    return defineQueryHandler({
+        name: "checkout-config",
+        schema: z.object({}),
+        access: { roles: ["anonymous", "User", "TenantAdmin", "SystemAdmin"] },
+        rateLimit: { per: "ip+handler", limit: 60, windowSeconds: 60 },
+        description: "Answers the public Paddle.js client token and the Paddle environment for the checkout page; the client token is public by design and no other config leaves this handler.",
+        handler: async (_query, ctx) => readCheckoutConfig(ctx),
+    });
+}

package/dist/subscription-paddle/checkout-methods.d.ts

@@ -0,0 +1,6 @@
+import type { PaddleCtxRuntime, PaddlePluginMethod } from "./runtime.ts";
+export declare function paddleSubscriptionPath(providerSubscriptionId: string): string;
+export declare function createPaddleCheckoutSession(runtime: PaddleCtxRuntime): PaddlePluginMethod<"createCheckoutSession">;
+export declare function createPaddlePortalSession(runtime: PaddleCtxRuntime): PaddlePluginMethod<"createPortalSession">;
+export declare function createPaddleCancelSubscription(runtime: PaddleCtxRuntime): PaddlePluginMethod<"cancelSubscription">;
+export declare function createPaddleResumeSubscription(runtime: PaddleCtxRuntime): PaddlePluginMethod<"resumeSubscription">;