@noodleseed/one 0.152.0 → 0.154.0

package/node_modules/@noodle-borg/transport-http/dist/index.js

@@ -1,8 +1,10 @@
 export { applySecurityHeaders, effectiveProto, enforceHttps, } from './front-door.js';
 export { createMcpHttpHandler, createMcpRouter, } from './handler.js';
+export { bearerToken } from './identity-authorization.js';
 export { createLogger, noopLogger, stderrSink, stdoutSink, } from './logging.js';
-export { readModuleJsonBody, sendModuleJson, } from './module-http.js';
 export { resolveTrustedPublicOrg, resolveTrustedTenantMcpResource, trustedPublicMcpRef, trustedPublicOrgWellKnownRef, } from './public-routing.js';
+export { readBody, readDeployBody, readJsonBody } from './request-body.js';
+export { sendJson } from './responses.js';
 export { serveHttp } from './serve.js';
 export { preflightServicePrincipalToolCall, sendServicePrincipalToolDenial, } from './service-principal-authorization.js';
 export { toWebRequest, writeWebResponse } from './web-bridge.js';

package/node_modules/@noodle-borg/transport-http/dist/request-body.d.ts

@@ -0,0 +1,29 @@
+import type { IncomingMessage } from 'node:http';
+export declare function readBody(req: IncomingMessage, max: number): Promise<{
+    ok: true;
+    text: string;
+} | {
+    ok: false;
+    receivedBytes: number;
+    maxBytes: number;
+}>;
+export declare function readDeployBody(req: IncomingMessage, max: number): Promise<{
+    ok: true;
+    text: string;
+    encoding: 'identity' | 'gzip';
+} | {
+    ok: false;
+    status: 400 | 413 | 415;
+    error: string;
+    receivedBytes?: number;
+    maxBytes?: number;
+}>;
+export declare function readJsonBody(req: IncomingMessage, max: number): Promise<{
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+    status: 400 | 413;
+    error: string;
+}>;
+//# sourceMappingURL=request-body.d.ts.map

package/node_modules/@noodle-borg/transport-http/dist/request-body.js

@@ -0,0 +1,64 @@
+import { gunzipSync } from 'node:zlib';
+export async function readBody(req, max) {
+    const body = await readBodyBuffer(req, max);
+    return body.ok ? { ok: true, text: body.buffer.toString('utf8') } : body;
+}
+async function readBodyBuffer(req, max) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of req) {
+        const buf = chunk;
+        size += buf.length;
+        if (size > max)
+            return { ok: false, receivedBytes: size, maxBytes: max };
+        chunks.push(buf);
+    }
+    return { ok: true, buffer: Buffer.concat(chunks) };
+}
+export async function readDeployBody(req, max) {
+    const encoding = (req.headers['content-encoding'] ?? 'identity').trim().toLowerCase();
+    if (encoding !== 'identity' && encoding !== 'gzip') {
+        return { ok: false, status: 415, error: `unsupported content encoding "${encoding}"` };
+    }
+    const body = await readBodyBuffer(req, max);
+    if (!body.ok) {
+        return {
+            ok: false,
+            status: 413,
+            error: `${encoding === 'gzip' ? 'compressed deploy' : 'deploy'} request exceeds the ${body.maxBytes} byte limit (received at least ${body.receivedBytes} bytes)`,
+            receivedBytes: body.receivedBytes,
+            maxBytes: body.maxBytes,
+        };
+    }
+    if (encoding === 'identity') {
+        return { ok: true, text: body.buffer.toString('utf8'), encoding };
+    }
+    try {
+        const expanded = gunzipSync(body.buffer, { maxOutputLength: max });
+        return { ok: true, text: expanded.toString('utf8'), encoding };
+    }
+    catch (error) {
+        const code = error instanceof Error && 'code' in error ? String(error.code) : '';
+        if (code === 'ERR_BUFFER_TOO_LARGE') {
+            return {
+                ok: false,
+                status: 413,
+                error: `expanded deploy request exceeds the ${max} byte limit`,
+                maxBytes: max,
+            };
+        }
+        return { ok: false, status: 400, error: 'invalid gzip deploy request' };
+    }
+}
+export async function readJsonBody(req, max) {
+    const body = await readBody(req, max);
+    if (!body.ok)
+        return { ok: false, status: 413, error: 'request body too large' };
+    try {
+        return { ok: true, value: JSON.parse(body.text) };
+    }
+    catch (error) {
+        return { ok: false, status: 400, error: `invalid JSON: ${error.message}` };
+    }
+}
+//# sourceMappingURL=request-body.js.map

package/node_modules/@noodle-borg/transport-http/dist/responses.d.ts

@@ -0,0 +1,28 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { AdmissionContext, AdmissionGate } from '@noodle-borg/module';
+import type { Logger } from './logging.js';
+/** Emit one `mcp.request` lifecycle line with safe scalar fields only. */
+export declare function logRequest(logger: Logger, routeId: string, req: IncomingMessage, res: ServerResponse, start: number): void;
+export declare function guard(res: ServerResponse, fn: Promise<void>): Promise<void>;
+export declare function sendJson(res: ServerResponse, status: number, body: unknown): void;
+/** A transport-level JSON-RPC error response with no id (per the Streamable HTTP spec). */
+export declare function rpcError(code: number, message: string): {
+    jsonrpc: '2.0';
+    id: null;
+    error: {
+        code: number;
+        message: string;
+    };
+};
+export declare function admissionRpcError(context: AdmissionContext, decision: Exclude<Awaited<ReturnType<AdmissionGate>>, {
+    allow: true;
+}>): {
+    jsonrpc: '2.0';
+    id: string | number | null;
+    error: {
+        code: number;
+        message: string;
+        data: Record<string, string | number>;
+    };
+};
+//# sourceMappingURL=responses.d.ts.map

package/node_modules/@noodle-borg/transport-http/dist/routing.d.ts

@@ -5,7 +5,7 @@ export interface PublicTenantRouting {
     readonly edgeToken: string;
     readonly resolveTenant: (ref: PublicMcpRouteRef) => Promise<TenantRouteRef | undefined>;
 }
-export type ParsedRoute = {
+type ParsedRoute = {
     readonly kind: 'tenant';
     readonly ref: TenantRouteRef;
     readonly logId: string;
@@ -23,7 +23,5 @@ export type RouteResolution = {
     readonly status: 403;
 };
 export declare function resolveRoute(req: IncomingMessage, pathname: string, publicTenantRouting: PublicTenantRouting | undefined): Promise<RouteResolution>;
-export declare function parseRoute(pathname: string): ParsedRoute | null;
-export declare function tenantLogId(ref: TenantRouteRef): string;
-export declare function safeDecode(value: string): string | null;
+export {};
 //# sourceMappingURL=routing.d.ts.map

package/node_modules/@noodle-borg/transport-http/dist/routing.js

@@ -27,7 +27,7 @@ export async function resolveRoute(req, pathname, publicTenantRouting) {
     }
     return { ok: true, route: parseRoute(pathname) };
 }
-export function parseRoute(pathname) {
+function parseRoute(pathname) {
     const tenant = parseLegacyTenantMcpPath(pathname);
     if (tenant !== undefined) {
         return { kind: 'tenant', ref: tenant, logId: tenantLogId(tenant) };
@@ -41,10 +41,10 @@ export function parseRoute(pathname) {
     }
     return null;
 }
-export function tenantLogId(ref) {
+function tenantLogId(ref) {
     return `${ref.org}/${ref.app}/${ref.env}${ref.serverVersion !== undefined ? `@${ref.serverVersion}` : ''}`;
 }
-export function safeDecode(value) {
+function safeDecode(value) {
     try {
         return decodeURIComponent(value);
     }

package/node_modules/@noodle-borg/transport-http/dist/serve-request.js

@@ -3,6 +3,7 @@ import { createDualEraMcpHandler, handleStatelessHttp, JSON_RPC, } from '@noodle
 import { admissionContexts, requestsInvocationContext } from './admission-context.js';
 import { authorizeIdentityMode, authorizeMixedMode, authorizePublicServiceMode, canonicalResourceUrl, isIdentityMode, } from './identity-authorization.js';
 import { invocationClientHint } from './invocation-client-hints.js';
+import { readBody } from './request-body.js';
 import { emitDeniedRequestEvent, emitIntentEvents, emitRequestEvent, header, } from './request-capture.js';
 import { admissionRpcError, rpcError, sendJson } from './responses.js';
 import { preflightServicePrincipalToolCall, sendServicePrincipalToolDenial, } from './service-principal-authorization.js';
@@ -284,21 +285,9 @@ function boundedReason(reason) {
         .slice(0, 32);
     return token.length === 0 ? 'denied' : token;
 }
-export function originAllowed(origin, allowed) {
+function originAllowed(origin, allowed) {
     if (allowed === undefined)
         return true;
     return typeof allowed === 'function' ? allowed(origin) : allowed.includes(origin);
 }
-export async function readBody(req, max) {
-    const chunks = [];
-    let size = 0;
-    for await (const chunk of req) {
-        const buf = chunk;
-        size += buf.length;
-        if (size > max)
-            return { ok: false };
-        chunks.push(buf);
-    }
-    return { ok: true, text: Buffer.concat(chunks).toString('utf8') };
-}
 //# sourceMappingURL=serve-request.js.map

package/node_modules/@noodle-borg/transport-http/package.json

@@ -28,7 +28,6 @@
   "devDependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@noodle-borg/compiler": "0.0.0",
-    "@noodle-borg/connector-http": "0.0.0",
     "@noodle-borg/runtime": "0.0.0",
     "@types/node": "^24.13.1"
   }

package/node_modules/@noodle-borg/wire-contracts/dist/app-purge-reconciliation.d.ts

@@ -0,0 +1,177 @@
+import { z } from 'zod';
+export declare const APP_PURGE_RECONCILIATION_SCHEMA_VERSION: 1;
+export declare const APP_PURGE_RECONCILIATION_MAX_CANDIDATES = 100;
+export declare const APP_PURGE_RECONCILIATION_PREVIEW_TTL_MS: number;
+export declare const AppPurgeReconciliationEnvironmentSchema: z.ZodObject<{
+    name: z.ZodString;
+    isProduction: z.ZodBoolean;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type AppPurgeReconciliationEnvironmentV1 = z.infer<typeof AppPurgeReconciliationEnvironmentSchema>;
+export declare const AppPurgeReconciliationCandidateSchema: z.ZodObject<{
+    org: z.ZodString;
+    app: z.ZodString;
+    anchorCreatedAt: z.ZodISODateTime;
+    purgeAuditId: z.ZodString;
+    environments: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        isProduction: z.ZodBoolean;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type AppPurgeReconciliationCandidateV1 = z.infer<typeof AppPurgeReconciliationCandidateSchema>;
+export declare const AppPurgeReconciliationPreviewRequestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type AppPurgeReconciliationPreviewRequestV1 = z.infer<typeof AppPurgeReconciliationPreviewRequestSchema>;
+export declare const AppPurgeReconciliationPreviewArtifactSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    releaseSha: z.ZodString;
+    createdAt: z.ZodISODateTime;
+    expiresAt: z.ZodISODateTime;
+    candidateCount: z.ZodNumber;
+    truncated: z.ZodBoolean;
+    candidates: z.ZodArray<z.ZodObject<{
+        org: z.ZodString;
+        app: z.ZodString;
+        anchorCreatedAt: z.ZodISODateTime;
+        purgeAuditId: z.ZodString;
+        environments: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            isProduction: z.ZodBoolean;
+            createdAt: z.ZodISODateTime;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    checksum: z.ZodString;
+}, z.core.$strict>;
+export type AppPurgeReconciliationPreviewArtifactV1 = z.infer<typeof AppPurgeReconciliationPreviewArtifactSchema>;
+type ReadonlyDeep<Value> = Value extends readonly (infer Item)[] ? readonly ReadonlyDeep<Item>[] : Value extends object ? {
+    readonly [Key in keyof Value]: ReadonlyDeep<Value[Key]>;
+} : Value;
+export type AppPurgeReconciliationUnsignedPreviewArtifactV1 = Omit<ReadonlyDeep<AppPurgeReconciliationPreviewArtifactV1>, 'checksum'>;
+export declare const AppPurgeReconciliationPreviewResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    artifact: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        releaseSha: z.ZodString;
+        createdAt: z.ZodISODateTime;
+        expiresAt: z.ZodISODateTime;
+        candidateCount: z.ZodNumber;
+        truncated: z.ZodBoolean;
+        candidates: z.ZodArray<z.ZodObject<{
+            org: z.ZodString;
+            app: z.ZodString;
+            anchorCreatedAt: z.ZodISODateTime;
+            purgeAuditId: z.ZodString;
+            environments: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                isProduction: z.ZodBoolean;
+                createdAt: z.ZodISODateTime;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        checksum: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type AppPurgeReconciliationPreviewResponseV1 = z.infer<typeof AppPurgeReconciliationPreviewResponseSchema>;
+export declare const AppPurgeReconciliationApplyRequestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    preview: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        releaseSha: z.ZodString;
+        createdAt: z.ZodISODateTime;
+        expiresAt: z.ZodISODateTime;
+        candidateCount: z.ZodNumber;
+        truncated: z.ZodBoolean;
+        candidates: z.ZodArray<z.ZodObject<{
+            org: z.ZodString;
+            app: z.ZodString;
+            anchorCreatedAt: z.ZodISODateTime;
+            purgeAuditId: z.ZodString;
+            environments: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                isProduction: z.ZodBoolean;
+                createdAt: z.ZodISODateTime;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        checksum: z.ZodString;
+    }, z.core.$strict>;
+    releaseSha: z.ZodString;
+    approvalReference: z.ZodString;
+    recoveryCheckpoint: z.ZodString;
+    reason: z.ZodString;
+    idempotencyKey: z.ZodString;
+    confirmed: z.ZodLiteral<true>;
+}, z.core.$strict>;
+export type AppPurgeReconciliationApplyRequestV1 = z.infer<typeof AppPurgeReconciliationApplyRequestSchema>;
+export declare const AppPurgeReconciliationApplyResultSchema: z.ZodObject<{
+    operationId: z.ZodString;
+    previewChecksum: z.ZodString;
+    releaseSha: z.ZodString;
+    candidateCount: z.ZodNumber;
+    deletedCount: z.ZodNumber;
+    appliedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type AppPurgeReconciliationApplyResultV1 = z.infer<typeof AppPurgeReconciliationApplyResultSchema>;
+export declare const AppPurgeReconciliationApplyResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    replayed: z.ZodBoolean;
+    result: z.ZodObject<{
+        operationId: z.ZodString;
+        previewChecksum: z.ZodString;
+        releaseSha: z.ZodString;
+        candidateCount: z.ZodNumber;
+        deletedCount: z.ZodNumber;
+        appliedAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type AppPurgeReconciliationApplyResponseV1 = z.infer<typeof AppPurgeReconciliationApplyResponseSchema>;
+/** Client reader strips additive fields at every response layer while service output stays strict. */
+export declare const AppPurgeReconciliationClientResponseSchema: z.ZodUnion<readonly [z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    artifact: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        releaseSha: z.ZodString;
+        createdAt: z.ZodISODateTime;
+        expiresAt: z.ZodISODateTime;
+        candidateCount: z.ZodNumber;
+        truncated: z.ZodBoolean;
+        candidates: z.ZodArray<z.ZodObject<{
+            org: z.ZodString;
+            app: z.ZodString;
+            anchorCreatedAt: z.ZodISODateTime;
+            purgeAuditId: z.ZodString;
+            environments: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                isProduction: z.ZodBoolean;
+                createdAt: z.ZodISODateTime;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        checksum: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    replayed: z.ZodBoolean;
+    result: z.ZodObject<{
+        operationId: z.ZodString;
+        previewChecksum: z.ZodString;
+        releaseSha: z.ZodString;
+        candidateCount: z.ZodNumber;
+        deletedCount: z.ZodNumber;
+        appliedAt: z.ZodISODateTime;
+    }, z.core.$strip>;
+}, z.core.$strip>]>;
+export type AppPurgeReconciliationClientResponseV1 = z.infer<typeof AppPurgeReconciliationClientResponseSchema>;
+export declare const AppPurgeReconciliationErrorCodeSchema: z.ZodEnum<{
+    app_purge_preview_expired: "app_purge_preview_expired";
+    app_purge_release_mismatch: "app_purge_release_mismatch";
+    app_purge_preview_mismatch: "app_purge_preview_mismatch";
+    app_purge_candidate_drift: "app_purge_candidate_drift";
+    app_purge_idempotency_conflict: "app_purge_idempotency_conflict";
+    app_purge_reconciliation_unavailable: "app_purge_reconciliation_unavailable";
+}>;
+export type AppPurgeReconciliationErrorCodeV1 = z.infer<typeof AppPurgeReconciliationErrorCodeSchema>;
+/** Exact unsigned bytes hashed for a preview checksum. */
+export declare function appPurgeReconciliationChecksumPayload(unsignedArtifact: AppPurgeReconciliationUnsignedPreviewArtifactV1): string;
+export {};
+//# sourceMappingURL=app-purge-reconciliation.d.ts.map

package/node_modules/@noodle-borg/wire-contracts/dist/app-purge-reconciliation.js

@@ -0,0 +1,189 @@
+import { z } from 'zod';
+const SLUG_PATTERN = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+const slug = z.string().regex(SLUG_PATTERN);
+const timestamp = z.iso.datetime({ offset: true });
+const releaseSha = z.string().regex(/^[0-9a-f]{40}$/);
+const checksum = z.string().regex(/^sha256:[0-9a-f]{64}$/);
+export const APP_PURGE_RECONCILIATION_SCHEMA_VERSION = 1;
+export const APP_PURGE_RECONCILIATION_MAX_CANDIDATES = 100;
+export const APP_PURGE_RECONCILIATION_PREVIEW_TTL_MS = 15 * 60 * 1000;
+export const AppPurgeReconciliationEnvironmentSchema = z.strictObject({
+    name: slug,
+    isProduction: z.boolean(),
+    createdAt: timestamp,
+});
+export const AppPurgeReconciliationCandidateSchema = z.strictObject({
+    org: slug,
+    app: slug,
+    anchorCreatedAt: timestamp,
+    purgeAuditId: z.string().uuid(),
+    environments: z.array(AppPurgeReconciliationEnvironmentSchema),
+});
+export const AppPurgeReconciliationPreviewRequestSchema = z.strictObject({
+    schemaVersion: z.literal(APP_PURGE_RECONCILIATION_SCHEMA_VERSION),
+    limit: z.number().int().min(1).max(APP_PURGE_RECONCILIATION_MAX_CANDIDATES).optional(),
+});
+function checkArtifactInvariants(artifact, context) {
+    if (Date.parse(artifact.expiresAt) - Date.parse(artifact.createdAt) !==
+        APP_PURGE_RECONCILIATION_PREVIEW_TTL_MS) {
+        context.addIssue({
+            code: 'custom',
+            path: ['expiresAt'],
+            message: 'expiresAt must be exactly 15 minutes after createdAt',
+        });
+    }
+    if (artifact.candidateCount !== artifact.candidates.length) {
+        context.addIssue({
+            code: 'custom',
+            path: ['candidateCount'],
+            message: 'candidateCount must equal candidates.length',
+        });
+    }
+    if (artifact.candidateCount === 0 && artifact.truncated) {
+        context.addIssue({
+            code: 'custom',
+            path: ['truncated'],
+            message: 'a zero-candidate artifact cannot be truncated',
+        });
+    }
+    let previousCandidateKey;
+    for (const [candidateIndex, candidate] of artifact.candidates.entries()) {
+        const candidateKey = `${candidate.org}\u0000${candidate.app}`;
+        if (previousCandidateKey !== undefined && previousCandidateKey >= candidateKey) {
+            context.addIssue({
+                code: 'custom',
+                path: ['candidates', candidateIndex],
+                message: 'candidates must be unique and lexically ordered by org and app',
+            });
+        }
+        previousCandidateKey = candidateKey;
+        let previousEnvironmentName;
+        for (const [environmentIndex, environment] of candidate.environments.entries()) {
+            if (previousEnvironmentName !== undefined && previousEnvironmentName >= environment.name) {
+                context.addIssue({
+                    code: 'custom',
+                    path: ['candidates', candidateIndex, 'environments', environmentIndex],
+                    message: 'environments must be unique and lexically ordered by name',
+                });
+            }
+            previousEnvironmentName = environment.name;
+        }
+    }
+}
+const previewArtifactShape = {
+    schemaVersion: z.literal(APP_PURGE_RECONCILIATION_SCHEMA_VERSION),
+    releaseSha,
+    createdAt: timestamp,
+    expiresAt: timestamp,
+    candidateCount: z.number().int().min(0).max(APP_PURGE_RECONCILIATION_MAX_CANDIDATES),
+    truncated: z.boolean(),
+    candidates: z.array(AppPurgeReconciliationCandidateSchema),
+    checksum,
+};
+export const AppPurgeReconciliationPreviewArtifactSchema = z
+    .strictObject(previewArtifactShape)
+    .superRefine(checkArtifactInvariants);
+export const AppPurgeReconciliationPreviewResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    artifact: AppPurgeReconciliationPreviewArtifactSchema,
+});
+export const AppPurgeReconciliationApplyRequestSchema = z.strictObject({
+    schemaVersion: z.literal(APP_PURGE_RECONCILIATION_SCHEMA_VERSION),
+    preview: AppPurgeReconciliationPreviewArtifactSchema,
+    releaseSha,
+    approvalReference: z.string().trim().min(1).max(256),
+    recoveryCheckpoint: z.string().trim().min(1).max(256),
+    reason: z.string().trim().min(1).max(500),
+    idempotencyKey: z.string().min(8).max(256),
+    confirmed: z.literal(true),
+});
+export const AppPurgeReconciliationApplyResultSchema = z.strictObject({
+    operationId: z.string().uuid(),
+    previewChecksum: checksum,
+    releaseSha,
+    candidateCount: z.number().int().min(0).max(APP_PURGE_RECONCILIATION_MAX_CANDIDATES),
+    deletedCount: z.number().int().min(0).max(APP_PURGE_RECONCILIATION_MAX_CANDIDATES),
+    appliedAt: timestamp,
+});
+export const AppPurgeReconciliationApplyResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    replayed: z.boolean(),
+    result: AppPurgeReconciliationApplyResultSchema,
+});
+const ClientEnvironmentSchema = z.object({
+    name: slug,
+    isProduction: z.boolean(),
+    createdAt: timestamp,
+});
+const ClientCandidateSchema = z.object({
+    org: slug,
+    app: slug,
+    anchorCreatedAt: timestamp,
+    purgeAuditId: z.string().uuid(),
+    environments: z.array(ClientEnvironmentSchema),
+});
+const ClientPreviewArtifactSchema = z
+    .object({
+    schemaVersion: z.literal(APP_PURGE_RECONCILIATION_SCHEMA_VERSION),
+    releaseSha,
+    createdAt: timestamp,
+    expiresAt: timestamp,
+    candidateCount: z.number().int().min(0).max(APP_PURGE_RECONCILIATION_MAX_CANDIDATES),
+    truncated: z.boolean(),
+    candidates: z.array(ClientCandidateSchema),
+    checksum,
+})
+    .superRefine(checkArtifactInvariants);
+const ClientPreviewResponseSchema = z.object({
+    ok: z.literal(true),
+    artifact: ClientPreviewArtifactSchema,
+});
+const ClientApplyResultSchema = z.object({
+    operationId: z.string().uuid(),
+    previewChecksum: checksum,
+    releaseSha,
+    candidateCount: z.number().int().min(0).max(APP_PURGE_RECONCILIATION_MAX_CANDIDATES),
+    deletedCount: z.number().int().min(0).max(APP_PURGE_RECONCILIATION_MAX_CANDIDATES),
+    appliedAt: timestamp,
+});
+const ClientApplyResponseSchema = z.object({
+    ok: z.literal(true),
+    replayed: z.boolean(),
+    result: ClientApplyResultSchema,
+});
+/** Client reader strips additive fields at every response layer while service output stays strict. */
+export const AppPurgeReconciliationClientResponseSchema = z.union([
+    ClientPreviewResponseSchema,
+    ClientApplyResponseSchema,
+]);
+export const AppPurgeReconciliationErrorCodeSchema = z.enum([
+    'app_purge_preview_expired',
+    'app_purge_release_mismatch',
+    'app_purge_preview_mismatch',
+    'app_purge_candidate_drift',
+    'app_purge_idempotency_conflict',
+    'app_purge_reconciliation_unavailable',
+]);
+/** Exact unsigned bytes hashed for a preview checksum. */
+export function appPurgeReconciliationChecksumPayload(unsignedArtifact) {
+    return JSON.stringify({
+        schemaVersion: unsignedArtifact.schemaVersion,
+        releaseSha: unsignedArtifact.releaseSha,
+        createdAt: unsignedArtifact.createdAt,
+        expiresAt: unsignedArtifact.expiresAt,
+        candidateCount: unsignedArtifact.candidateCount,
+        truncated: unsignedArtifact.truncated,
+        candidates: unsignedArtifact.candidates.map((candidate) => ({
+            org: candidate.org,
+            app: candidate.app,
+            anchorCreatedAt: candidate.anchorCreatedAt,
+            purgeAuditId: candidate.purgeAuditId,
+            environments: candidate.environments.map((environment) => ({
+                name: environment.name,
+                isProduction: environment.isProduction,
+                createdAt: environment.createdAt,
+            })),
+        })),
+    });
+}
+//# sourceMappingURL=app-purge-reconciliation.js.map

package/node_modules/@noodle-borg/wire-contracts/dist/assistant.d.ts

@@ -204,11 +204,11 @@ export declare const assistantWireEventSchema: z.ZodUnion<readonly [z.ZodObject<
 }, z.core.$strip>, z.ZodObject<{
     event: z.ZodLiteral<string>;
     data: z.ZodObject<{
+        result: z.ZodJSONSchema;
         tool: z.ZodString;
         id: z.ZodString;
         resourceUri: z.ZodString;
         title: z.ZodOptional<z.ZodString>;
-        result: z.ZodJSONSchema;
         arguments: z.ZodOptional<z.ZodJSONSchema>;
         resourceMeta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         allowedOpenDomains: z.ZodOptional<z.ZodArray<z.ZodURL>>;