@noodleseed/one 0.172.1 → 0.173.0

package/node_modules/@noodle-borg/cli-catalog/dist/catalog-data-solution-drafts.js

@@ -0,0 +1,141 @@
+/** Canonical source-draft operations; imported by the solutions family. Data only. */
+import { EXPECTED_REVISION, IDEMPOTENCY_KEY, OPTIONAL_FLAG, REQUIRED_ARGUMENT, SOLUTION_COMMON_FLAGS, } from './catalog-data-solution-flags.js';
+const common = [
+    ...SOLUTION_COMMON_FLAGS.map((flag) => flag.name === 'org' ? { ...flag, required: true } : flag),
+    {
+        ...OPTIONAL_FLAG,
+        name: 'app',
+        type: 'string',
+        value: '<slug>',
+        required: true,
+        summary: 'Application slug.',
+    },
+];
+const source = [
+    {
+        ...OPTIONAL_FLAG,
+        name: 'source-dir',
+        type: 'string',
+        value: '<directory>',
+        required: true,
+        summary: 'Directory containing bounded TypeScript application source; no symlinks or environment files.',
+    },
+    {
+        ...OPTIONAL_FLAG,
+        name: 'entrypoint',
+        type: 'string',
+        value: '<path>',
+        summary: 'Relative TypeScript entrypoint.',
+        constraints: { default: 'server.ts' },
+    },
+];
+const draftId = { ...REQUIRED_ARGUMENT, name: 'draft-id', summary: 'Saved draft identifier.' };
+const revision = { ...EXPECTED_REVISION, constraints: { minimum: 1, maximum: 2147483647 } };
+export const SOLUTION_DRAFTS = {
+    name: 'drafts',
+    summary: 'Save and inspect private application source without publishing it.',
+    arguments: [],
+    flags: [],
+    subcommands: [
+        {
+            name: 'history',
+            summary: 'List source-free revisions, newest first.',
+            arguments: [draftId],
+            flags: common,
+            jsonOutput: { mode: 'single' },
+        },
+        {
+            name: 'diff',
+            summary: 'Compare exact source and entrypoints at two revisions.',
+            arguments: [draftId],
+            flags: [
+                ...common,
+                { ...revision, name: 'from-revision', summary: 'Revision to compare from.' },
+                { ...revision, name: 'to-revision', summary: 'Revision to compare to.' },
+            ],
+            jsonOutput: { mode: 'single' },
+        },
+        {
+            name: 'list',
+            summary: 'List source-free draft summaries.',
+            arguments: [],
+            flags: common,
+            jsonOutput: { mode: 'single' },
+        },
+        {
+            name: 'show',
+            summary: 'Read an authorized exact draft revision.',
+            arguments: [draftId],
+            flags: [
+                ...common,
+                {
+                    ...revision,
+                    name: 'revision',
+                    required: false,
+                    summary: 'Revision to read; defaults to the current revision.',
+                },
+            ],
+            jsonOutput: { mode: 'single' },
+        },
+        {
+            name: 'create',
+            summary: 'Save a new private draft from TypeScript source.',
+            arguments: [],
+            flags: [
+                ...common,
+                ...source,
+                IDEMPOTENCY_KEY,
+                {
+                    ...OPTIONAL_FLAG,
+                    name: 'env',
+                    type: 'string',
+                    value: '<slug>',
+                    summary: 'Intended publish environment; saving does not deploy.',
+                    constraints: { default: 'prod' },
+                },
+            ],
+            jsonOutput: { mode: 'single' },
+        },
+        {
+            name: 'edit',
+            summary: 'Append a revision without overwriting concurrent work.',
+            arguments: [draftId],
+            flags: [...common, ...source, revision, IDEMPOTENCY_KEY],
+            jsonOutput: { mode: 'single' },
+        },
+        {
+            name: 'undo',
+            summary: 'Restore an earlier source revision as a new revision.',
+            arguments: [draftId],
+            flags: [
+                ...common,
+                revision,
+                IDEMPOTENCY_KEY,
+                {
+                    ...revision,
+                    name: 'target-revision',
+                    summary: 'Earlier revision whose source will be restored.',
+                },
+            ],
+            jsonOutput: { mode: 'single' },
+        },
+        {
+            name: 'delete',
+            summary: 'Erase a draft and its source history; published applications are unchanged.',
+            arguments: [draftId],
+            flags: [
+                ...common,
+                revision,
+                {
+                    ...OPTIONAL_FLAG,
+                    name: 'confirm',
+                    type: 'boolean',
+                    required: true,
+                    summary: 'Confirm erasing the draft source and history.',
+                },
+            ],
+            jsonOutput: { mode: 'single' },
+        },
+    ],
+};
+//# sourceMappingURL=catalog-data-solution-drafts.js.map

package/node_modules/@noodle-borg/cli-catalog/dist/catalog-data-solution-page.js

@@ -0,0 +1,57 @@
+/** Hosted-page operator catalog. Pure data; execution remains in the CLI. */
+import { EXPECTED_REVISION, INSTALLATION_ARGUMENT, OPTIONAL_FLAG, SOLUTION_COMMON_FLAGS, } from './catalog-data-solution-flags.js';
+const common = SOLUTION_COMMON_FLAGS.map((flag) => flag.name === 'org' ? { ...flag, required: true } : flag);
+const revision = {
+    ...EXPECTED_REVISION,
+    constraints: { minimum: 1, maximum: 2147483647 },
+};
+const confirm = {
+    ...OPTIONAL_FLAG,
+    name: 'confirm',
+    type: 'boolean',
+    required: true,
+    summary: 'Confirm changing public page availability.',
+};
+export const SOLUTION_PAGE = {
+    name: 'page',
+    summary: 'Edit and explicitly publish a Noodle Seed-hosted business page.',
+    arguments: [],
+    flags: [],
+    subcommands: [
+        {
+            name: 'show',
+            summary: 'Inspect the private page draft and its published snapshot.',
+            arguments: [INSTALLATION_ARGUMENT],
+            flags: common,
+            jsonOutput: { mode: 'single' },
+        },
+        {
+            name: 'save',
+            summary: 'Save page content without changing the published page.',
+            arguments: [INSTALLATION_ARGUMENT],
+            flags: [
+                ...common,
+                { ...revision, constraints: { minimum: 0, maximum: 2147483647 } },
+                {
+                    ...OPTIONAL_FLAG,
+                    name: 'data',
+                    type: 'string',
+                    value: '<json>',
+                    required: true,
+                    summary: 'Bounded JSON with introduction and sections containing title/text; plain text only.',
+                },
+            ],
+            jsonOutput: { mode: 'single' },
+        },
+        ...['publish', 'unpublish'].map((name) => ({
+            name,
+            summary: name === 'publish'
+                ? 'Publish the exact saved page after public-assistant readiness checks.'
+                : 'Remove the public page while retaining its private draft.',
+            arguments: [INSTALLATION_ARGUMENT],
+            flags: [...common, revision, confirm],
+            jsonOutput: { mode: 'single' },
+        })),
+    ],
+};
+//# sourceMappingURL=catalog-data-solution-page.js.map

package/node_modules/@noodle-borg/cli-catalog/dist/catalog-data-solutions.js

@@ -1,5 +1,7 @@
 /** Solution installation/operator catalog. Imports only dependency-free sibling data. */
+import { SOLUTION_DRAFTS } from './catalog-data-solution-drafts.js';
 import { AUTH_TOKEN, EXPECTED_REVISION, IDEMPOTENCY_KEY, INSTALLATION_ARGUMENT, JSON_FLAG, OPTIONAL_FLAG, PAGING_FLAGS, REQUIRED_ARGUMENT, SERVICE, SOLUTION_COMMON_FLAGS, } from './catalog-data-solution-flags.js';
+import { SOLUTION_PAGE } from './catalog-data-solution-page.js';
 const APP = {
     ...OPTIONAL_FLAG,
     name: 'app',
@@ -129,6 +131,8 @@ export const CATALOG_SOLUTIONS = {
     arguments: [],
     flags: [],
     subcommands: [
+        SOLUTION_DRAFTS,
+        SOLUTION_PAGE,
         {
             name: 'installation-options',
             summary: 'List organizations currently authorized to install solutions.',

package/node_modules/@noodle-borg/service/dist/application-drafts/contracts.js

@@ -0,0 +1,11 @@
+export class ApplicationDraftError extends Error {
+    code;
+    currentRevision;
+    constructor(code, currentRevision) {
+        super(code);
+        this.code = code;
+        this.currentRevision = currentRevision;
+        this.name = 'ApplicationDraftError';
+    }
+}
+//# sourceMappingURL=contracts.js.map

package/node_modules/@noodle-borg/service/dist/application-drafts/paths.js

@@ -0,0 +1,26 @@
+import { validateSlug } from '@noodle-borg/control-plane/portable';
+import { ApplicationDraftIdSchema } from '@noodle-borg/wire-contracts';
+export function parseApplicationDraftPath(path) {
+    const match = /^\/v1\/orgs\/([a-z0-9-]+)\/apps\/([a-z0-9-]+)\/drafts(?:\/([a-f0-9-]+)(?:\/(undo|history|diff))?)?$/.exec(path);
+    const org = match?.[1], app = match?.[2], id = match?.[3], action = match?.[4];
+    if (!org || !app || (id !== undefined && !ApplicationDraftIdSchema.safeParse(id).success))
+        return undefined;
+    try {
+        validateSlug('org', org);
+        validateSlug('app', app);
+    }
+    catch {
+        return undefined;
+    }
+    return { org, app, ...(id ? { id } : {}), ...(action ? { action } : {}) };
+}
+export function applicationDraftMethods(ref) {
+    return ref.action === 'undo'
+        ? ['POST']
+        : ref.action
+            ? ['GET']
+            : ref.id
+                ? ['GET', 'PATCH', 'DELETE']
+                : ['GET', 'POST'];
+}
+//# sourceMappingURL=paths.js.map

package/node_modules/@noodle-borg/service/dist/business-information/business-page-paths.js

@@ -0,0 +1,14 @@
+export function parseBusinessPagePath(path) {
+    const match = /^\/v1\/orgs\/([a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?)\/solution-installations\/([a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?)\/page(?:\/(publish|unpublish))?$/.exec(path);
+    return match
+        ? {
+            org: match[1],
+            installationId: match[2],
+            ...(match[3] ? { operation: match[3] } : {}),
+        }
+        : undefined;
+}
+export function businessPageMethods(ref) {
+    return ref.operation ? ['POST'] : ['GET', 'PUT'];
+}
+//# sourceMappingURL=business-page-paths.js.map

package/node_modules/@noodle-borg/service/dist/business-information/business-page.d.ts

@@ -0,0 +1,39 @@
+import { type BusinessPageContent, type BusinessPagePublication } from '@noodle-borg/wire-contracts';
+import type { BusinessNoticeRecord } from './business-notice.js';
+import type { InstallationScope } from './contracts.js';
+export interface BusinessPageRecord {
+    readonly revision: number;
+    readonly draft: BusinessPageContent;
+    readonly published: BusinessPagePublication | null;
+    readonly updatedAt: string;
+    readonly updatedBySubject: string;
+}
+export type BusinessPageChange = {
+    readonly operation: 'save';
+    readonly expectedRevision: number;
+    readonly content: BusinessPageContent;
+} | {
+    readonly operation: 'publish' | 'unpublish';
+    readonly expectedRevision: number;
+};
+export interface BusinessPageInput {
+    readonly scope: InstallationScope;
+    readonly actorSubject: string;
+    readonly change: BusinessPageChange;
+}
+/** Server-only readiness check, never supplied by a browser or persisted as authority. */
+export type BusinessPageReadiness = () => Promise<{
+    readonly deploymentId: string;
+}>;
+export interface BusinessPageStore {
+    get(scope: InstallationScope): Promise<BusinessPageRecord | undefined>;
+    update(input: BusinessPageInput, assertReady?: BusinessPageReadiness): Promise<BusinessPageRecord>;
+}
+export declare class BusinessPageError extends Error {
+    readonly code: 'business_page_forbidden' | 'business_page_conflict' | 'business_page_not_ready';
+    constructor(code: 'business_page_forbidden' | 'business_page_conflict' | 'business_page_not_ready');
+}
+export declare function nextBusinessPage(current: BusinessPageRecord | undefined, input: BusinessPageInput, now: string, notice: BusinessNoticeRecord | undefined, assertReady?: BusinessPageReadiness): Promise<BusinessPageRecord>;
+/** Validate decrypted storage without surfacing parser excerpts or business text in errors. */
+export declare function decodeBusinessPage(value: unknown, expectedRevision: number): BusinessPageRecord;
+//# sourceMappingURL=business-page.d.ts.map

package/node_modules/@noodle-borg/service/dist/business-information/business-page.js

@@ -0,0 +1,81 @@
+import { BusinessPageContentSchema, BusinessPagePublicationSchema, BusinessPagePublishRequestSchema, BusinessPageSaveRequestSchema, } from '@noodle-borg/wire-contracts';
+export class BusinessPageError extends Error {
+    code;
+    constructor(code) {
+        super({
+            business_page_forbidden: 'An active business administrator is required.',
+            business_page_conflict: 'The page changed. Reload before trying again.',
+            business_page_not_ready: 'Complete the business details and enable the public assistant before publishing.',
+        }[code]);
+        this.code = code;
+        this.name = 'BusinessPageError';
+    }
+}
+export async function nextBusinessPage(current, input, now, notice, assertReady) {
+    const { operation, ...request } = input.change;
+    if (!['save', 'publish', 'unpublish'].includes(operation))
+        throw new Error('Invalid page operation.');
+    const save = operation === 'save' ? BusinessPageSaveRequestSchema.parse(request) : undefined;
+    const expectedRevision = save?.expectedRevision ?? BusinessPagePublishRequestSchema.parse(request).expectedRevision;
+    if ((current?.revision ?? 0) !== expectedRevision || expectedRevision === 2_147_483_647)
+        throw new BusinessPageError('business_page_conflict');
+    if (operation !== 'save' && !current)
+        throw new BusinessPageError('business_page_conflict');
+    const draft = save?.content ?? current?.draft;
+    if (!draft)
+        throw new BusinessPageError('business_page_conflict');
+    let published = current?.published ?? null;
+    if (operation === 'publish') {
+        if (!notice || !assertReady)
+            throw new BusinessPageError('business_page_not_ready');
+        const ready = await assertReady();
+        published = BusinessPagePublicationSchema.parse({
+            content: draft,
+            notice: notice.notice,
+            noticeRevision: notice.revision,
+            sourceRevision: expectedRevision,
+            deploymentId: ready.deploymentId,
+            publishedAt: now,
+        });
+    }
+    else if (operation === 'unpublish')
+        published = null;
+    return structuredClone({
+        revision: expectedRevision + 1,
+        draft,
+        published,
+        updatedAt: now,
+        updatedBySubject: input.actorSubject,
+    });
+}
+/** Validate decrypted storage without surfacing parser excerpts or business text in errors. */
+export function decodeBusinessPage(value, expectedRevision) {
+    try {
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            throw new Error();
+        const input = value;
+        if (Object.keys(input).sort().join(',') !==
+            'draft,published,revision,updatedAt,updatedBySubject' ||
+            input.revision !== expectedRevision ||
+            !Number.isInteger(expectedRevision) ||
+            expectedRevision < 1 ||
+            expectedRevision > 2_147_483_647 ||
+            typeof input.updatedAt !== 'string' ||
+            !Number.isFinite(Date.parse(input.updatedAt)) ||
+            typeof input.updatedBySubject !== 'string' ||
+            !input.updatedBySubject ||
+            input.updatedBySubject.length > 500)
+            throw new Error();
+        return {
+            revision: expectedRevision,
+            draft: BusinessPageContentSchema.parse(input.draft),
+            published: input.published === null ? null : BusinessPagePublicationSchema.parse(input.published),
+            updatedAt: input.updatedAt,
+            updatedBySubject: input.updatedBySubject,
+        };
+    }
+    catch {
+        throw new Error('Business page storage is unavailable.');
+    }
+}
+//# sourceMappingURL=business-page.js.map

package/node_modules/@noodle-borg/service/dist/business-information/contracts.d.ts

@@ -1,6 +1,7 @@
 import type { ArtifactVariableDeclaration, ManagedCollectionControls } from '@noodle-borg/compiler';
 import type { ManagedRecordQuery } from '@noodle-borg/wire-contracts';
 import type { BusinessNoticeStore } from './business-notice.js';
+import type { BusinessPageStore } from './business-page.js';
 import type { BusinessPrincipalProvider } from './principal-authority.js';
 export type JsonPrimitive = string | number | boolean | null;
 export type JsonValue = JsonPrimitive | JsonObject | readonly JsonValue[];
@@ -433,6 +434,7 @@ export interface ManagedRequestStore {
     }): Promise<number>;
 }
 export interface BusinessInformationStore extends SolutionInstallationStore, BusinessNoticeStore, BusinessGrantStore, ManagedRequestStore {
+    readonly pages: BusinessPageStore;
     configurePrincipalAuthority(provider: BusinessPrincipalProvider | undefined): void;
     listEligibleAssignees(scope: InstallationScope): Promise<readonly BusinessGrant[]>;
 }

package/node_modules/@noodle-borg/service/dist/business-information/in-memory-business-pages.js

@@ -0,0 +1,37 @@
+import { BusinessPageError, nextBusinessPage, } from './business-page.js';
+import { scopeKey } from './pagination.js';
+import { validateScalar, validateScope } from './validation.js';
+/** Process-local test/development adapter; shares installation grant authority and its locks. */
+export class InMemoryBusinessPages {
+    business;
+    locks;
+    principals;
+    now;
+    #records = new Map();
+    constructor(business, locks, principals, now) {
+        this.business = business;
+        this.locks = locks;
+        this.principals = principals;
+        this.now = now;
+    }
+    async get(scope) {
+        return structuredClone(this.#records.get(scopeKey(validateScope(scope))));
+    }
+    async update(input, assertReady) {
+        const scope = validateScope(input.scope);
+        const actorSubject = validateScalar('page actor', input.actorSubject, 500);
+        const key = scopeKey(scope);
+        return this.locks.run(`grants:${key}`, () => this.locks.run(`intake:${key}`, async () => {
+            const grant = await this.business.getGrant(scope, actorSubject);
+            if (!(await this.business.getInstallation(scope)) ||
+                grant?.role !== 'administrator' ||
+                grant.revokedAt ||
+                !(await this.principals.allows(actorSubject)))
+                throw new BusinessPageError('business_page_forbidden');
+            const next = await nextBusinessPage(this.#records.get(key), { ...input, scope, actorSubject }, this.now().toISOString(), await this.business.getBusinessNotice(scope), assertReady);
+            this.#records.set(key, structuredClone(next));
+            return next;
+        }));
+    }
+}
+//# sourceMappingURL=in-memory-business-pages.js.map

package/node_modules/@noodle-borg/service/dist/business-information/in-memory-store.js

@@ -1,6 +1,7 @@
 import { randomUUID } from 'node:crypto';
 import { memoryActivityPage } from './activity-pagination.js';
 import { collectionControlEnabled } from './collection-controls.js';
+import { InMemoryBusinessPages } from './in-memory-business-pages.js';
 import { InMemoryInstallationLifecycle, } from './in-memory-installation-lifecycle.js';
 import { InMemoryBusinessInvitations } from './in-memory-invitations.js';
 import { BusinessMemoryLocks } from './in-memory-locks.js';
@@ -14,6 +15,7 @@ import { BusinessPrincipalAuthority, } from './principal-authority.js';
 import { boundedExportPageSize, boundedPageSize, validateEmail, validateScalar, validateScope, } from './validation.js';
 /** Process-local development/test adapter. Hosted services must use the PostgreSQL adapter. */
 export class InMemoryBusinessInformationStore {
+    pages;
     #installations = new Map();
     #installationIds = new Map();
     #publicIds = new Map();
@@ -36,6 +38,7 @@ export class InMemoryBusinessInformationStore {
         this.#id = options.id ?? randomUUID;
         this.#publicId = options.publicId ?? (() => `sol_${randomUUID().replaceAll('-', '')}`);
         this.#managedDefinition = options.managedDefinition;
+        this.pages = new InMemoryBusinessPages(this, this.#locks, this.#principals, this.#now);
         this.#lifecycle = new InMemoryInstallationLifecycle({
             installations: this.#installations,
             getGrant: (scope, subject) => this.#grants.get(grantKey(scope, subject)),

package/node_modules/@noodle-borg/service/dist/business-information/managed-solution-executable.js

@@ -2,7 +2,15 @@ import { projectManagedCollectionControls, RECORD_OPERATION_SIGNATURES, } from '
 import { collectionToPublicWire } from '../routes/business-information-wire.js';
 import { managedSolutionBlueprint } from './managed-solution-blueprints.js';
 /** System-owned manifest data for an explicitly curated solution, admitted by the ordinary compiler. */
-export function managedSolutionManifest(definition) {
+export function managedSolutionManifest(definition, hostedPageOrigin) {
+    if (hostedPageOrigin !== undefined) {
+        const url = new URL(hostedPageOrigin);
+        if (url.origin !== hostedPageOrigin ||
+            !(url.protocol === 'https:' ||
+                (url.protocol === 'http:' && ['localhost', '127.0.0.1', '[::1]'].includes(url.hostname))))
+            throw new Error('Invalid hosted page origin');
+    }
+    const origins = ['${env.WEBSITE_ORIGIN}', ...(hostedPageOrigin ? [hostedPageOrigin] : [])];
     const ref = definition.reference;
     const blueprint = ref.kind === 'managed' ? managedSolutionBlueprint(ref.definitionId, ref.release) : undefined;
     if (blueprint === undefined)
@@ -40,11 +48,11 @@ export function managedSolutionManifest(definition) {
             })),
             assistant: {
                 model: { kind: 'noodle-managed' },
-                allowedOrigins: ['${env.WEBSITE_ORIGIN}'],
+                allowedOrigins: origins,
                 surfaces: [
                     {
                         mode: 'public',
-                        origins: ['${env.WEBSITE_ORIGIN}'],
+                        origins,
                         capabilities: [{ kind: 'tool', name: blueprint.tool }],
                     },
                 ],

package/node_modules/@noodle-borg/service/dist/routes/application-drafts.js

@@ -0,0 +1,162 @@
+import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
+import { APPLICATION_DRAFT_LIMITS, ApplicationDraftCreateRequestSchema, ApplicationDraftDiffRequestSchema, ApplicationDraftDiffResponseSchema, ApplicationDraftEditRequestSchema, ApplicationDraftHistoryResponseSchema, ApplicationDraftListResponseSchema, ApplicationDraftResponseSchema, ApplicationDraftRevisionRequestSchema, ApplicationDraftUndoRequestSchema, } from '@noodle-borg/wire-contracts';
+import { ApplicationDraftError } from '../application-drafts/contracts.js';
+import { applicationDraftMethods, parseApplicationDraftPath } from '../application-drafts/paths.js';
+import { admitBusinessTarget, authorizeBusinessApi } from '../business-api-admission.js';
+import { requestIdempotencyKey } from './business-information-request.js';
+/** This bounded authoring surface never forwards a Portal token to general deployment/secrets APIs. */
+export async function handleApplicationDraftRoute(req, res, url, deps) {
+    res.setHeader('cache-control', 'private, no-store');
+    try {
+        await handle(req, res, url, deps);
+    }
+    catch (error) {
+        if (error instanceof ApplicationDraftError) {
+            const status = error.code === 'forbidden'
+                ? 403
+                : error.code === 'not_found'
+                    ? 404
+                    : error.code === 'draft_deleted'
+                        ? 410
+                        : error.code === 'invalid_draft'
+                            ? 400
+                            : 409;
+            return sendJson(res, status, {
+                error: error.code.replaceAll('_', ' '),
+                code: error.code,
+                ...(error.currentRevision === undefined ? {} : { currentRevision: error.currentRevision }),
+            });
+        }
+        // Do not reflect compiler/source/cipher errors or log their customer-controlled messages.
+        return sendJson(res, 503, {
+            error: 'Draft storage is temporarily unavailable.',
+            code: 'drafts_unavailable',
+        });
+    }
+}
+async function handle(req, res, url, deps) {
+    const ref = parseApplicationDraftPath(url.pathname);
+    if (!ref)
+        return sendJson(res, 404, { error: 'draft route not found' });
+    const { org, app, id, action } = ref;
+    const identity = await authorizeBusinessApi(req, res, deps);
+    if (!identity)
+        return;
+    const permission = req.method === 'GET' ? 'drafts:read' : 'drafts:edit';
+    if ((await deps.workspaces.authorize(org, identity.subject, permission)) !== 'allowed') {
+        return sendJson(res, 403, { error: 'Workspace draft permission required.', code: 'forbidden' });
+    }
+    if (!(await admitBusinessTarget(res, { org })))
+        return;
+    const scope = { org, app }, actorSubject = identity.subject;
+    if (id && req.method === 'GET' && action === 'history') {
+        if ([...url.searchParams].length)
+            return invalid(res);
+        const revisions = await deps.drafts.history(scope, id, actorSubject);
+        return sendJson(res, 200, ApplicationDraftHistoryResponseSchema.parse({ ok: true, data: { revisions } }));
+    }
+    if (id && req.method === 'GET' && action === 'diff') {
+        if ([...url.searchParams].length !== 2 ||
+            [...url.searchParams].some(([key, value]) => !['from', 'to'].includes(key) || !/^[1-9]\d{0,9}$/.test(value)))
+            return invalid(res);
+        const parsed = ApplicationDraftDiffRequestSchema.safeParse({
+            from: Number(url.searchParams.get('from')),
+            to: Number(url.searchParams.get('to')),
+        });
+        if (!parsed.success)
+            return invalid(res);
+        const diff = await deps.drafts.diff(scope, id, actorSubject, parsed.data.from, parsed.data.to);
+        return sendJson(res, 200, ApplicationDraftDiffResponseSchema.parse({ ok: true, data: { diff } }));
+    }
+    if (req.method === 'GET' && action === undefined) {
+        if (id === undefined) {
+            if ([...url.searchParams].length)
+                return invalid(res);
+            const drafts = await deps.drafts.list(scope, actorSubject);
+            return sendJson(res, 200, ApplicationDraftListResponseSchema.parse({ ok: true, data: { drafts } }));
+        }
+        const queries = [...url.searchParams];
+        const value = url.searchParams.get('revision');
+        if (queries.length > 1 ||
+            queries.some(([key]) => key !== 'revision') ||
+            (value !== null && (!/^[1-9]\d{0,9}$/.test(value) || Number(value) > 2147483647)))
+            return invalid(res);
+        const draft = await deps.drafts.get(scope, id, actorSubject, value === null ? undefined : Number(value));
+        return sendJson(res, 200, ApplicationDraftResponseSchema.parse({ ok: true, data: { draft } }));
+    }
+    const allowed = applicationDraftMethods(ref);
+    if (!allowed.includes(req.method ?? '')) {
+        res.setHeader('allow', allowed.join(', '));
+        return sendJson(res, 405, { error: 'method not allowed' });
+    }
+    if ([...url.searchParams].length)
+        return invalid(res);
+    const body = await readJsonBody(req, Math.min(deps.maxBody, APPLICATION_DRAFT_LIMITS.totalBytes * 6 + 32_768));
+    if (!body.ok)
+        return sendJson(res, body.status, { error: body.error });
+    if (id !== undefined && req.method === 'DELETE') {
+        const parsed = ApplicationDraftRevisionRequestSchema.safeParse(body.value);
+        if (!parsed.success)
+            return invalid(res);
+        await deps.drafts.remove({
+            scope,
+            id,
+            actorSubject,
+            expectedRevision: parsed.data.expectedRevision,
+        });
+        res.writeHead(204);
+        res.end();
+        return;
+    }
+    const idempotencyKey = requestIdempotencyKey(req);
+    if (!idempotencyKey)
+        return invalid(res);
+    if (id === undefined && req.method === 'POST') {
+        const parsed = ApplicationDraftCreateRequestSchema.safeParse(body.value);
+        if (!parsed.success)
+            return invalid(res);
+        const draft = await deps.drafts.create({
+            scope,
+            actorSubject,
+            idempotencyKey,
+            environment: parsed.data.environment,
+            source: parsed.data.source,
+            ...(parsed.data.baseRelease === undefined ? {} : { baseRelease: parsed.data.baseRelease }),
+        });
+        return sendJson(res, 201, ApplicationDraftResponseSchema.parse({ ok: true, data: { draft } }));
+    }
+    if (id && req.method === 'PATCH') {
+        const parsed = ApplicationDraftEditRequestSchema.safeParse(body.value);
+        if (!parsed.success)
+            return invalid(res);
+        const draft = await deps.drafts.edit({
+            scope,
+            id,
+            actorSubject,
+            idempotencyKey,
+            ...parsed.data,
+        });
+        return sendJson(res, 200, ApplicationDraftResponseSchema.parse({ ok: true, data: { draft } }));
+    }
+    if (id && action === 'undo' && req.method === 'POST') {
+        const parsed = ApplicationDraftUndoRequestSchema.safeParse(body.value);
+        if (!parsed.success)
+            return invalid(res);
+        const draft = await deps.drafts.undo({
+            scope,
+            id,
+            actorSubject,
+            idempotencyKey,
+            ...parsed.data,
+        });
+        return sendJson(res, 200, ApplicationDraftResponseSchema.parse({ ok: true, data: { draft } }));
+    }
+    return invalid(res);
+}
+function invalid(res) {
+    sendJson(res, 400, {
+        error: 'Invalid draft request. Review the source, revision and retry key.',
+        code: 'invalid_draft',
+    });
+}
+//# sourceMappingURL=application-drafts.js.map