@astrale-domains/services 0.4.9 → 0.5.0

package/dist/schema/modules/service/functions/delete-service-secret.js

@@ -1,3 +0,0 @@
-import { method } from '@astrale-os/sdk/schema';
-import { deleteServiceSecretContract } from '../types/service-management.js';
-export const deleteServiceSecret = method({ ...deleteServiceSecretContract, abstract: true });

package/dist/schema/modules/service/functions/delete-worker-secret.d.ts

@@ -1,11 +0,0 @@
-export declare const deleteWorkerSecret: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
-    name: string;
-}, {
-    readonly mode: 'value';
-    readonly value: {
-        ok: true;
-    } | {
-        kind: "rejected";
-        reason: "binding-unavailable" | "invalid-secret-name" | "service-unavailable";
-    };
-}, "authorized", false, false, undefined>>;

package/dist/schema/modules/service/functions/delete-worker-secret.js

@@ -1,7 +0,0 @@
-import { method } from '@astrale-os/sdk/schema';
-import { OwnService } from '../policies/own-service.js';
-import { deleteServiceSecretContract } from '../types/service-management.js';
-export const deleteWorkerSecret = method({
-    ...deleteServiceSecretContract,
-    policy: ({ check, self }) => check(OwnService, self),
-});

package/dist/schema/modules/service/functions/delete-worker.d.ts

@@ -1,9 +0,0 @@
-export declare const deleteWorker: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
-    readonly mode: 'value';
-    readonly value: {
-        kind: "deleted";
-    } | {
-        kind: "deleting";
-        retryAfterMs: number;
-    };
-}, "authorized", false, false, undefined>>;

package/dist/schema/modules/service/functions/delete-worker.js

@@ -1,7 +0,0 @@
-import { method } from '@astrale-os/sdk/schema';
-import { OwnService } from '../policies/own-service.js';
-import { deleteServiceContract } from '../types/service-management.js';
-export const deleteWorker = method({
-    ...deleteServiceContract,
-    policy: ({ check, self }) => check(OwnService, self),
-});

package/dist/schema/modules/service/functions/deploy-cloudflare-worker.d.ts

@@ -1,109 +0,0 @@
-export declare const deployCloudflareWorker: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
-    name?: string | undefined;
-    entry?: string | undefined;
-    modules?: ({
-        name: string;
-        kind?: "data" | "esm" | "text" | "wasm" | undefined;
-        content: {
-            encoding: "gzip" | "identity";
-            decodedSize: number;
-            contentBase64: string;
-        } | {
-            encoding: "gzip" | "identity";
-            decodedSize: number;
-            contentBase64Chunks: string[];
-        };
-    } | {
-        contentBase64: string;
-        name: string;
-        kind?: "data" | "esm" | "text" | "wasm" | undefined;
-    } | {
-        contentBase64Chunks: string[];
-        name: string;
-        kind?: "data" | "esm" | "text" | "wasm" | undefined;
-    })[] | undefined;
-    revisioned?: {
-        requiredSecrets: string[];
-        release: {
-            entry: string;
-            modules: ({
-                name: string;
-                kind?: "data" | "esm" | "text" | "wasm" | undefined;
-                content: {
-                    encoding: "gzip" | "identity";
-                    decodedSize: number;
-                    contentBase64: string;
-                } | {
-                    encoding: "gzip" | "identity";
-                    decodedSize: number;
-                    contentBase64Chunks: string[];
-                };
-            } | {
-                contentBase64: string;
-                name: string;
-                kind?: "data" | "esm" | "text" | "wasm" | undefined;
-            } | {
-                contentBase64Chunks: string[];
-                name: string;
-                kind?: "data" | "esm" | "text" | "wasm" | undefined;
-            })[];
-        };
-        readiness?: {
-            paths: string[];
-            required?: boolean | undefined;
-        } | undefined;
-    } | undefined;
-    compatibilityDate?: string | undefined;
-    compatibilityFlags?: string[] | undefined;
-    serviceBindings?: {
-        name: string;
-        service: string;
-    }[] | undefined;
-    vars?: Record<string, string> | undefined;
-    secrets?: Record<string, string> | undefined;
-    assets?: {
-        files: ({
-            path: string;
-            contentType?: string | undefined;
-            content: {
-                encoding: "gzip" | "identity";
-                decodedSize: number;
-                contentBase64: string;
-            } | {
-                encoding: "gzip" | "identity";
-                decodedSize: number;
-                contentBase64Chunks: string[];
-            };
-        } | {
-            contentBase64: string;
-            path: string;
-            contentType?: string | undefined;
-        } | {
-            contentBase64Chunks: string[];
-            path: string;
-            contentType?: string | undefined;
-        })[];
-        notFound?: "404-page" | "none" | "single-page-application" | undefined;
-        runWorkerFirst?: boolean | undefined;
-        htmlHandling?: "none" | undefined;
-    } | undefined;
-    limits?: {
-        cpuMs?: number | undefined;
-        subrequests?: number | undefined;
-    } | undefined;
-    serviceKey: string;
-}, {
-    readonly mode: 'value';
-    readonly value: {
-        id: string;
-        serviceKey: string;
-        url: string;
-        digest: string;
-        state: "ready";
-        candidateReadiness?: "passed" | "unavailable-retained-secrets" | undefined;
-    } | {
-        kind: "rejected";
-        reason: "artifact-mode-conflict" | "invalid-deployment" | "service-unavailable";
-        message: string;
-    };
-}, "authenticated", true, false, undefined>>;

package/dist/schema/modules/service/functions/deploy-cloudflare-worker.js

@@ -1,9 +0,0 @@
-import { method } from '@astrale-os/sdk/schema';
-import { deployServiceInput, deployServiceOutput } from '../types/deploy-cloudflare-worker.js';
-export const deployCloudflareWorker = method({
-    description: 'Create or converge one Cloudflare Worker Service.',
-    auth: 'authenticated',
-    static: true,
-    input: deployServiceInput,
-    output: deployServiceOutput,
-});

package/dist/schema/modules/service/functions/list-worker-logs.d.ts

@@ -1,12 +0,0 @@
-export declare const listWorkerLogs: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
-    tail?: number | undefined;
-    since?: number | undefined;
-}, {
-    readonly mode: 'value';
-    readonly value: {
-        id: string;
-        ts: number;
-        level: string;
-        line: string;
-    }[];
-}, "authorized", false, false, undefined>>;

package/dist/schema/modules/service/functions/list-worker-logs.js

@@ -1,7 +0,0 @@
-import { method } from '@astrale-os/sdk/schema';
-import { OwnService } from '../policies/own-service.js';
-import { listServiceLogsContract } from '../types/service-management.js';
-export const listWorkerLogs = method({
-    ...listServiceLogsContract,
-    policy: ({ check, self }) => check(OwnService, self),
-});

package/dist/schema/modules/service/functions/list-worker-schedules.d.ts

@@ -1,4 +0,0 @@
-export declare const listWorkerSchedules: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
-    readonly mode: 'value';
-    readonly value: string[];
-}, "authorized", false, false, undefined>>;

package/dist/schema/modules/service/functions/list-worker-schedules.js

@@ -1,7 +0,0 @@
-import { method } from '@astrale-os/sdk/schema';
-import { OwnService } from '../policies/own-service.js';
-import { listServiceSchedulesContract } from '../types/service-management.js';
-export const listWorkerSchedules = method({
-    ...listServiceSchedulesContract,
-    policy: ({ check, self }) => check(OwnService, self),
-});

package/dist/schema/modules/service/functions/list-worker-secret-names.d.ts

@@ -1,4 +0,0 @@
-export declare const listWorkerSecretNames: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
-    readonly mode: 'value';
-    readonly value: string[];
-}, "authorized", false, false, undefined>>;

package/dist/schema/modules/service/functions/list-worker-secret-names.js

@@ -1,7 +0,0 @@
-import { method } from '@astrale-os/sdk/schema';
-import { OwnService } from '../policies/own-service.js';
-import { listServiceSecretNamesContract } from '../types/service-management.js';
-export const listWorkerSecretNames = method({
-    ...listServiceSecretNamesContract,
-    policy: ({ check, self }) => check(OwnService, self),
-});

package/dist/schema/modules/service/functions/migrate-worker-ingress.d.ts

@@ -1,24 +0,0 @@
-export declare const migrateWorkerIngress: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
-    action: "complete" | "detach" | "restore";
-    probe: {
-        path: string;
-        status: number;
-        bodySha256: string;
-    };
-}, {
-    readonly mode: 'value';
-    readonly value: {
-        kind: "detached";
-        detachedAt: string;
-    } | {
-        kind: "migrated";
-    } | {
-        kind: "restored";
-    } | {
-        kind: "pending";
-        retryAfterMs: number;
-    } | {
-        kind: "rejected";
-        reason: "missing-location" | "not-detached" | "service-unavailable";
-    };
-}, "authorized", false, false, undefined>>;

package/dist/schema/modules/service/functions/migrate-worker-ingress.js

@@ -1,26 +0,0 @@
-import { method } from '@astrale-os/sdk/schema';
-import { z } from 'zod';
-import { OwnService } from '../policies/own-service.js';
-export const migrateWorkerIngress = method({
-    description: 'Migrate legacy ingress to the shared wildcard, retaining cleanup evidence until verified; optionally restore the domain before finalization.',
-    auth: 'authorized',
-    input: z.strictObject({
-        action: z.enum(['detach', 'complete', 'restore']),
-        probe: z.strictObject({
-            path: z.string().min(1).max(1024),
-            status: z.number().int().min(200).max(299),
-            bodySha256: z.string().min(64).max(64),
-        }),
-    }),
-    output: z.discriminatedUnion('kind', [
-        z.strictObject({ kind: z.literal('detached'), detachedAt: z.string().min(20).max(30) }),
-        z.strictObject({ kind: z.literal('migrated') }),
-        z.strictObject({ kind: z.literal('restored') }),
-        z.strictObject({ kind: z.literal('pending'), retryAfterMs: z.number().int().positive() }),
-        z.strictObject({
-            kind: z.literal('rejected'),
-            reason: z.enum(['service-unavailable', 'missing-location', 'not-detached']),
-        }),
-    ]),
-    policy: ({ check, self }) => check(OwnService, self),
-});

package/dist/schema/modules/service/functions/replace-worker-schedules.d.ts

@@ -1,11 +0,0 @@
-export declare const replaceWorkerSchedules: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
-    crons: string[];
-}, {
-    readonly mode: 'value';
-    readonly value: {
-        crons: string[];
-    } | {
-        kind: "rejected";
-        reason: "invalid-schedule" | "service-unavailable";
-    };
-}, "authorized", false, false, undefined>>;

package/dist/schema/modules/service/functions/replace-worker-schedules.js

@@ -1,7 +0,0 @@
-import { method } from '@astrale-os/sdk/schema';
-import { OwnService } from '../policies/own-service.js';
-import { replaceServiceSchedulesContract } from '../types/service-management.js';
-export const replaceWorkerSchedules = method({
-    ...replaceServiceSchedulesContract,
-    policy: ({ check, self }) => check(OwnService, self),
-});

package/dist/schema/modules/service/functions/set-worker-secret.d.ts

@@ -1,12 +0,0 @@
-export declare const setWorkerSecret: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
-    name: string;
-    value: string;
-}, {
-    readonly mode: 'value';
-    readonly value: {
-        kind: "rejected";
-        reason: "binding-unavailable" | "invalid-secret-name" | "service-unavailable";
-    } | {
-        name: string;
-    };
-}, "authorized", false, false, undefined>>;

package/dist/schema/modules/service/functions/set-worker-secret.js

@@ -1,7 +0,0 @@
-import { method } from '@astrale-os/sdk/schema';
-import { OwnService } from '../policies/own-service.js';
-import { setServiceSecretContract } from '../types/service-management.js';
-export const setWorkerSecret = method({
-    ...setServiceSecretContract,
-    policy: ({ check, self }) => check(OwnService, self),
-});

package/dist/schema/modules/service/types/deploy-cloudflare-worker.d.ts

@@ -1,286 +0,0 @@
-import { z } from 'zod';
-export declare const artifact: z.ZodObject<{
-    entry: z.ZodString;
-    modules: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-        name: z.ZodString;
-        kind: z.ZodOptional<z.ZodEnum<{
-            data: "data";
-            esm: "esm";
-            text: "text";
-            wasm: "wasm";
-        }>>;
-        content: z.ZodUnion<readonly [z.ZodObject<{
-            encoding: z.ZodEnum<{
-                gzip: "gzip";
-                identity: "identity";
-            }>;
-            decodedSize: z.ZodNumber;
-            contentBase64: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            encoding: z.ZodEnum<{
-                gzip: "gzip";
-                identity: "identity";
-            }>;
-            decodedSize: z.ZodNumber;
-            contentBase64Chunks: z.ZodArray<z.ZodString>;
-        }, z.core.$strict>]>;
-    }, z.core.$strict>, z.ZodObject<{
-        contentBase64: z.ZodString;
-        name: z.ZodString;
-        kind: z.ZodOptional<z.ZodEnum<{
-            data: "data";
-            esm: "esm";
-            text: "text";
-            wasm: "wasm";
-        }>>;
-    }, z.core.$strict>, z.ZodObject<{
-        contentBase64Chunks: z.ZodArray<z.ZodString>;
-        name: z.ZodString;
-        kind: z.ZodOptional<z.ZodEnum<{
-            data: "data";
-            esm: "esm";
-            text: "text";
-            wasm: "wasm";
-        }>>;
-    }, z.core.$strict>]>>;
-}, z.core.$strict>;
-export declare const revisionedDeployment: z.ZodObject<{
-    requiredSecrets: z.ZodArray<z.ZodString>;
-    release: z.ZodObject<{
-        entry: z.ZodString;
-        modules: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-            name: z.ZodString;
-            kind: z.ZodOptional<z.ZodEnum<{
-                data: "data";
-                esm: "esm";
-                text: "text";
-                wasm: "wasm";
-            }>>;
-            content: z.ZodUnion<readonly [z.ZodObject<{
-                encoding: z.ZodEnum<{
-                    gzip: "gzip";
-                    identity: "identity";
-                }>;
-                decodedSize: z.ZodNumber;
-                contentBase64: z.ZodString;
-            }, z.core.$strict>, z.ZodObject<{
-                encoding: z.ZodEnum<{
-                    gzip: "gzip";
-                    identity: "identity";
-                }>;
-                decodedSize: z.ZodNumber;
-                contentBase64Chunks: z.ZodArray<z.ZodString>;
-            }, z.core.$strict>]>;
-        }, z.core.$strict>, z.ZodObject<{
-            contentBase64: z.ZodString;
-            name: z.ZodString;
-            kind: z.ZodOptional<z.ZodEnum<{
-                data: "data";
-                esm: "esm";
-                text: "text";
-                wasm: "wasm";
-            }>>;
-        }, z.core.$strict>, z.ZodObject<{
-            contentBase64Chunks: z.ZodArray<z.ZodString>;
-            name: z.ZodString;
-            kind: z.ZodOptional<z.ZodEnum<{
-                data: "data";
-                esm: "esm";
-                text: "text";
-                wasm: "wasm";
-            }>>;
-        }, z.core.$strict>]>>;
-    }, z.core.$strict>;
-    readiness: z.ZodOptional<z.ZodObject<{
-        paths: z.ZodArray<z.ZodString>;
-        required: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export declare const deployServiceInput: z.ZodObject<{
-    name: z.ZodOptional<z.ZodString>;
-    entry: z.ZodOptional<z.ZodString>;
-    modules: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-        name: z.ZodString;
-        kind: z.ZodOptional<z.ZodEnum<{
-            data: "data";
-            esm: "esm";
-            text: "text";
-            wasm: "wasm";
-        }>>;
-        content: z.ZodUnion<readonly [z.ZodObject<{
-            encoding: z.ZodEnum<{
-                gzip: "gzip";
-                identity: "identity";
-            }>;
-            decodedSize: z.ZodNumber;
-            contentBase64: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            encoding: z.ZodEnum<{
-                gzip: "gzip";
-                identity: "identity";
-            }>;
-            decodedSize: z.ZodNumber;
-            contentBase64Chunks: z.ZodArray<z.ZodString>;
-        }, z.core.$strict>]>;
-    }, z.core.$strict>, z.ZodObject<{
-        contentBase64: z.ZodString;
-        name: z.ZodString;
-        kind: z.ZodOptional<z.ZodEnum<{
-            data: "data";
-            esm: "esm";
-            text: "text";
-            wasm: "wasm";
-        }>>;
-    }, z.core.$strict>, z.ZodObject<{
-        contentBase64Chunks: z.ZodArray<z.ZodString>;
-        name: z.ZodString;
-        kind: z.ZodOptional<z.ZodEnum<{
-            data: "data";
-            esm: "esm";
-            text: "text";
-            wasm: "wasm";
-        }>>;
-    }, z.core.$strict>]>>>;
-    revisioned: z.ZodOptional<z.ZodObject<{
-        requiredSecrets: z.ZodArray<z.ZodString>;
-        release: z.ZodObject<{
-            entry: z.ZodString;
-            modules: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-                name: z.ZodString;
-                kind: z.ZodOptional<z.ZodEnum<{
-                    data: "data";
-                    esm: "esm";
-                    text: "text";
-                    wasm: "wasm";
-                }>>;
-                content: z.ZodUnion<readonly [z.ZodObject<{
-                    encoding: z.ZodEnum<{
-                        gzip: "gzip";
-                        identity: "identity";
-                    }>;
-                    decodedSize: z.ZodNumber;
-                    contentBase64: z.ZodString;
-                }, z.core.$strict>, z.ZodObject<{
-                    encoding: z.ZodEnum<{
-                        gzip: "gzip";
-                        identity: "identity";
-                    }>;
-                    decodedSize: z.ZodNumber;
-                    contentBase64Chunks: z.ZodArray<z.ZodString>;
-                }, z.core.$strict>]>;
-            }, z.core.$strict>, z.ZodObject<{
-                contentBase64: z.ZodString;
-                name: z.ZodString;
-                kind: z.ZodOptional<z.ZodEnum<{
-                    data: "data";
-                    esm: "esm";
-                    text: "text";
-                    wasm: "wasm";
-                }>>;
-            }, z.core.$strict>, z.ZodObject<{
-                contentBase64Chunks: z.ZodArray<z.ZodString>;
-                name: z.ZodString;
-                kind: z.ZodOptional<z.ZodEnum<{
-                    data: "data";
-                    esm: "esm";
-                    text: "text";
-                    wasm: "wasm";
-                }>>;
-            }, z.core.$strict>]>>;
-        }, z.core.$strict>;
-        readiness: z.ZodOptional<z.ZodObject<{
-            paths: z.ZodArray<z.ZodString>;
-            required: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
-    compatibilityDate: z.ZodOptional<z.ZodString>;
-    compatibilityFlags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    serviceBindings: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        service: z.ZodString;
-    }, z.core.$strict>>>;
-    vars: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    secrets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    assets: z.ZodOptional<z.ZodObject<{
-        files: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-            path: z.ZodString;
-            contentType: z.ZodOptional<z.ZodString>;
-            content: z.ZodUnion<readonly [z.ZodObject<{
-                encoding: z.ZodEnum<{
-                    gzip: "gzip";
-                    identity: "identity";
-                }>;
-                decodedSize: z.ZodNumber;
-                contentBase64: z.ZodString;
-            }, z.core.$strict>, z.ZodObject<{
-                encoding: z.ZodEnum<{
-                    gzip: "gzip";
-                    identity: "identity";
-                }>;
-                decodedSize: z.ZodNumber;
-                contentBase64Chunks: z.ZodArray<z.ZodString>;
-            }, z.core.$strict>]>;
-        }, z.core.$strict>, z.ZodObject<{
-            contentBase64: z.ZodString;
-            path: z.ZodString;
-            contentType: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>, z.ZodObject<{
-            contentBase64Chunks: z.ZodArray<z.ZodString>;
-            path: z.ZodString;
-            contentType: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>]>>;
-        notFound: z.ZodOptional<z.ZodEnum<{
-            "404-page": "404-page";
-            none: "none";
-            "single-page-application": "single-page-application";
-        }>>;
-        runWorkerFirst: z.ZodOptional<z.ZodBoolean>;
-        htmlHandling: z.ZodOptional<z.ZodLiteral<"none">>;
-    }, z.core.$strict>>;
-    limits: z.ZodOptional<z.ZodObject<{
-        cpuMs: z.ZodOptional<z.ZodNumber>;
-        subrequests: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strict>>;
-    serviceKey: z.ZodString;
-}, z.core.$strict>;
-export type DeployServiceInput = z.infer<typeof deployServiceInput>;
-export declare const deployedService: z.ZodObject<{
-    id: z.ZodString;
-    serviceKey: z.ZodString;
-    url: z.ZodString;
-    digest: z.ZodString;
-    state: z.ZodLiteral<"ready">;
-    candidateReadiness: z.ZodOptional<z.ZodEnum<{
-        passed: "passed";
-        "unavailable-retained-secrets": "unavailable-retained-secrets";
-    }>>;
-}, z.core.$strict>;
-export declare const deploymentRejection: z.ZodObject<{
-    kind: z.ZodLiteral<"rejected">;
-    reason: z.ZodEnum<{
-        "artifact-mode-conflict": "artifact-mode-conflict";
-        "invalid-deployment": "invalid-deployment";
-        "service-unavailable": "service-unavailable";
-    }>;
-    message: z.ZodString;
-}, z.core.$strict>;
-export declare const deployServiceOutput: z.ZodUnion<readonly [z.ZodObject<{
-    id: z.ZodString;
-    serviceKey: z.ZodString;
-    url: z.ZodString;
-    digest: z.ZodString;
-    state: z.ZodLiteral<"ready">;
-    candidateReadiness: z.ZodOptional<z.ZodEnum<{
-        passed: "passed";
-        "unavailable-retained-secrets": "unavailable-retained-secrets";
-    }>>;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"rejected">;
-    reason: z.ZodEnum<{
-        "artifact-mode-conflict": "artifact-mode-conflict";
-        "invalid-deployment": "invalid-deployment";
-        "service-unavailable": "service-unavailable";
-    }>;
-    message: z.ZodString;
-}, z.core.$strict>]>;
-export type DeployServiceOutput = z.infer<typeof deployServiceOutput>;

package/dist/schema/modules/service/types/deploy-cloudflare-worker.js

@@ -1,51 +0,0 @@
-import { z } from 'zod';
-import { artifactModule } from './service-deployment-artifact-module.js';
-import { assetBundle } from './service-deployment-assets.js';
-import { resourceLimits } from './service-deployment-resource-limits.js';
-import { serviceReadiness } from './service-readiness.js';
-export const artifact = z.strictObject({
-    entry: z.string().min(1).max(256),
-    modules: z.array(artifactModule).min(1).max(40),
-});
-export const revisionedDeployment = z.strictObject({
-    requiredSecrets: z.array(z.string().min(1).max(128)).max(64),
-    release: artifact,
-    readiness: serviceReadiness.optional(),
-});
-const deployServiceFields = {
-    name: z.string().min(1).max(256).optional(),
-    entry: z.string().min(1).max(256).optional(),
-    modules: z.array(artifactModule).min(1).max(40).optional(),
-    revisioned: revisionedDeployment.optional(),
-    compatibilityDate: z.string().min(1).max(32).optional(),
-    compatibilityFlags: z.array(z.string().min(1).max(128)).max(64).optional(),
-    serviceBindings: z
-        .array(z.strictObject({
-        name: z.string().min(1).max(64),
-        service: z.string().min(1).max(128),
-    }))
-        .max(32)
-        .optional(),
-    vars: z.record(z.string().max(256), z.string().max(64 * 1024)).optional(),
-    secrets: z.record(z.string().max(256), z.string().max(64 * 1024)).optional(),
-    assets: assetBundle.optional(),
-    limits: resourceLimits,
-};
-export const deployServiceInput = z.strictObject({
-    serviceKey: z.string().min(1).max(63),
-    ...deployServiceFields,
-});
-export const deployedService = z.strictObject({
-    id: z.string().min(1),
-    serviceKey: z.string().min(1),
-    url: z.string(),
-    digest: z.string(),
-    state: z.literal('ready'),
-    candidateReadiness: z.enum(['passed', 'unavailable-retained-secrets']).optional(),
-});
-export const deploymentRejection = z.strictObject({
-    kind: z.literal('rejected'),
-    reason: z.enum(['invalid-deployment', 'service-unavailable', 'artifact-mode-conflict']),
-    message: z.string().min(1).max(500),
-});
-export const deployServiceOutput = z.union([deployedService, deploymentRejection]);