@astrale-domains/services 0.2.0

package/README.md

@@ -0,0 +1,37 @@
+# Services
+
+`services.astrale.ai` turns an authored module artifact into an owner-scoped, Cloudflare-backed
+Service. It keeps provider protocols behind a neutral SDK Integration and stores only admitted
+deployment evidence in the graph.
+
+## Model
+
+- `Service` records one opaque provider name, its public coordinate, deployment mode, URL, state,
+  and deployment digest.
+- `service_owned_by` connects the authenticated owner to each Service and governs graph visibility.
+- secret values stay write-only at Cloudflare and never enter Astrale mutations or graph state.
+- schedules remain provider state; only the owner may read or replace them.
+- logs are remote evidence admitted by the Cloudflare Provider before a Workflow returns them.
+
+`listServices` is a single-query Action. Deployment, secrets, schedules, logs, and deletion are
+Workflows because they coordinate caller authorization with external effects. `service-hosting` is
+the provider-neutral Integration contract; Cloudflare is its first Provider.
+
+## Development
+
+Copy `.env.example` to `.env.dev`, fill the Cloudflare values, then run:
+
+```sh
+pnpm typecheck
+pnpm test
+pnpm lint
+pnpm frontend:build
+pnpm build
+pnpm package
+```
+
+The deployed module named by `entry` must be present in `modules`. Module contents use one Base64
+string or bounded Base64 chunks when one string cannot cross the portable Value boundary; names are
+unique and secrets use environment-variable identifiers. Plain and revisioned artifacts are
+distinct modes and cannot replace each other at one Service record. Five-field cron expressions are
+supported when `CLOUDFLARE_SCHEDULE_KV_ID` is configured.

package/dist/schema/application/functions.js

@@ -0,0 +1,20 @@
+import { func } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+export const serviceRecord = z.strictObject({
+    id: z.string().min(1),
+    name: z.string().min(1),
+    description: z.string(),
+    providerName: z.string().min(1),
+    coordinate: z.string().min(1),
+    url: z.string().min(1).optional(),
+    state: z.enum(['deploying', 'ready', 'failed']),
+    digest: z.string().min(1).optional(),
+    revision: z.string().optional(),
+    error: z.string().optional(),
+});
+export const listServices = func({
+    description: 'List Services visible to the authenticated caller.',
+    auth: 'authenticated',
+    input: z.strictObject({}),
+    output: z.array(serviceRecord),
+});

package/dist/schema/application/index.d.ts

@@ -0,0 +1,391 @@
+import type { schema as language } from '@astrale-os/sdk/schema';
+import { KernelSchema } from '@astrale-os/sdk/schema';
+export declare const schema: import("@astrale-os/sdk/schema").DefinedSchema<"services.astrale.ai", import("@astrale-os/sdk/schema").ResolvedDomainOfInput<"services.astrale.ai", {
+    readonly dependencies: {
+        kernel: KernelSchema;
+    };
+    readonly classes: {
+        readonly CloudflareWorker: import("@astrale-os/sdk/schema").NodeClass<{
+            readonly depth: 1;
+            readonly abstract: false;
+            readonly extends: readonly [import("@astrale-os/sdk/schema").ClassProjection<"node", import("@astrale-os/sdk/schema").NodeClassDefinition & {
+                readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Named"> & {
+                    readonly origin: "kernel.astrale.ai";
+                };
+                readonly kind: 'node';
+                readonly abstract: true;
+            }, import("@astrale-os/sdk/schema").ClassRef & import("@astrale-os/sdk/schema").ClassRef<"Named"> & {
+                readonly origin: "kernel.astrale.ai";
+            }, "kernel.astrale.ai:class.Named", readonly [import("@astrale-os/sdk/schema").ClassProjection<"node", import("@astrale-os/sdk/schema").NodeClassDefinition & {
+                readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+                    readonly origin: "kernel.astrale.ai";
+                };
+                readonly kind: 'node';
+                readonly abstract: true;
+            }, import("@astrale-os/sdk/schema").ClassRef & import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+                readonly origin: "kernel.astrale.ai";
+            }, "kernel.astrale.ai:class.Node", readonly import("@astrale-os/sdk/schema").AnyResolvedClass[], never, never, never, never, never, never>, ...never[]], import("@astrale-os/sdk/schema").PropertyProjection<string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null, true, "name", "kernel.astrale.ai:class.Named.property.name">, never, never, import("@astrale-os/sdk/schema").PropertyProjection<string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null, true, "name", "kernel.astrale.ai:class.Named.property.name">, never, never>, import("@astrale-os/sdk/schema").ClassProjection<"node", import("@astrale-os/sdk/schema").NodeClassDefinition & {
+                readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Descriptable"> & {
+                    readonly origin: "kernel.astrale.ai";
+                };
+                readonly kind: 'node';
+                readonly abstract: true;
+            }, import("@astrale-os/sdk/schema").ClassRef & import("@astrale-os/sdk/schema").ClassRef<"Descriptable"> & {
+                readonly origin: "kernel.astrale.ai";
+            }, "kernel.astrale.ai:class.Descriptable", readonly [import("@astrale-os/sdk/schema").ClassProjection<"node", import("@astrale-os/sdk/schema").NodeClassDefinition & {
+                readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+                    readonly origin: "kernel.astrale.ai";
+                };
+                readonly kind: 'node';
+                readonly abstract: true;
+            }, import("@astrale-os/sdk/schema").ClassRef & import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+                readonly origin: "kernel.astrale.ai";
+            }, "kernel.astrale.ai:class.Node", readonly import("@astrale-os/sdk/schema").AnyResolvedClass[], never, never, never, never, never, never>, ...never[]], import("@astrale-os/sdk/schema").PropertyProjection<string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null, false, "description", "kernel.astrale.ai:class.Descriptable.property.description">, never, never, import("@astrale-os/sdk/schema").PropertyProjection<string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null, false, "description", "kernel.astrale.ai:class.Descriptable.property.description">, never, never>, import("@astrale-os/sdk/schema").ClassProjection<"node", import("@astrale-os/sdk/schema").NodeClassDefinition & {
+                readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Timestamped"> & {
+                    readonly origin: "kernel.astrale.ai";
+                };
+                readonly kind: 'node';
+                readonly abstract: true;
+            }, import("@astrale-os/sdk/schema").ClassRef & import("@astrale-os/sdk/schema").ClassRef<"Timestamped"> & {
+                readonly origin: "kernel.astrale.ai";
+            }, "kernel.astrale.ai:class.Timestamped", readonly [import("@astrale-os/sdk/schema").ClassProjection<"node", import("@astrale-os/sdk/schema").NodeClassDefinition & {
+                readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+                    readonly origin: "kernel.astrale.ai";
+                };
+                readonly kind: 'node';
+                readonly abstract: true;
+            }, import("@astrale-os/sdk/schema").ClassRef & import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+                readonly origin: "kernel.astrale.ai";
+            }, "kernel.astrale.ai:class.Node", readonly import("@astrale-os/sdk/schema").AnyResolvedClass[], never, never, never, never, never, never>, ...never[]], import("@astrale-os/sdk/schema").PropertyProjection<string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null, true, "createdAt", "kernel.astrale.ai:class.Timestamped.property.createdAt"> | import("@astrale-os/sdk/schema").PropertyProjection<string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null, true, "updatedAt", "kernel.astrale.ai:class.Timestamped.property.updatedAt">, never, never, import("@astrale-os/sdk/schema").PropertyProjection<string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null, true, "createdAt", "kernel.astrale.ai:class.Timestamped.property.createdAt"> | import("@astrale-os/sdk/schema").PropertyProjection<string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null, true, "updatedAt", "kernel.astrale.ai:class.Timestamped.property.updatedAt">, never, never>];
+            readonly properties: {
+                readonly providerKey: import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string, string, true, "providerKey", "self">;
+                readonly providerName: import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string, string, true, "providerName", "self">;
+                readonly deploymentMode: import("@astrale-os/sdk/schema").AuthoredPropertyProjection<"plain" | "revisioned", "plain" | "revisioned", true, "deploymentMode", "self">;
+                readonly url: import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string, string, false, "url", "self">;
+                readonly state: import("@astrale-os/sdk/schema").AuthoredPropertyProjection<"deploying" | "failed" | "ready", "deploying" | "failed" | "ready", true, "state", "self">;
+                readonly digest: import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string, string, false, "digest", "self">;
+                readonly revision: import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string, string, false, "revision", "self">;
+                readonly coordinate: import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string, string, true, "coordinate", "self">;
+                readonly deploymentReceipt: import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string, string, false, "deploymentReceipt", "self">;
+                readonly error: import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string, string, false, "error", "self">;
+            };
+            readonly methods: {
+                readonly deploy: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    path: string;
+                    name?: string | undefined;
+                    entry?: string | undefined;
+                    modules?: ({
+                        contentBase64: string;
+                        name: string;
+                        kind?: "data" | "esm" | "text" | "wasm" | undefined;
+                    } | {
+                        contentBase64Chunks: string[];
+                        name: string;
+                        kind?: "data" | "esm" | "text" | "wasm" | undefined;
+                    })[] | undefined;
+                    revisioned?: {
+                        revision: string;
+                        release: {
+                            entry: string;
+                            modules: ({
+                                contentBase64: string;
+                                name: string;
+                                kind?: "data" | "esm" | "text" | "wasm" | undefined;
+                            } | {
+                                contentBase64Chunks: string[];
+                                name: string;
+                                kind?: "data" | "esm" | "text" | "wasm" | undefined;
+                            })[];
+                        };
+                        gateway: {
+                            entry: string;
+                            modules: ({
+                                contentBase64: string;
+                                name: string;
+                                kind?: "data" | "esm" | "text" | "wasm" | undefined;
+                            } | {
+                                contentBase64Chunks: string[];
+                                name: string;
+                                kind?: "data" | "esm" | "text" | "wasm" | 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: ({
+                            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;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        path: string;
+                        url: string;
+                        digest: string;
+                        revision?: string | undefined;
+                        state: "deploying" | "failed" | "ready";
+                        error?: string | null | undefined;
+                        functions: {
+                            id: string;
+                            path: string;
+                            ref: string;
+                        }[];
+                    };
+                }, "authenticated", true, "default">>;
+                readonly setSecret: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                    value: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        name: string;
+                    };
+                }, "authenticated", false, "default">>;
+                readonly deleteSecret: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        ok: true;
+                    };
+                }, "authenticated", false, "default">>;
+                readonly secrets: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+                    readonly mode: 'value';
+                    readonly value: string[];
+                }, "authenticated", false, "default">>;
+                readonly setSchedule: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    crons: string[];
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        crons: string[];
+                    };
+                }, "authenticated", false, "default">>;
+                readonly schedules: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+                    readonly mode: 'value';
+                    readonly value: string[];
+                }, "authenticated", false, "default">>;
+                readonly logs: 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;
+                    }[];
+                }, "authenticated", false, "default">>;
+                readonly delete: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        ok: true;
+                    };
+                }, "authenticated", false, "default">>;
+            };
+            readonly effectiveProperties: (import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string, string, true, "coordinate", "self"> | import("@astrale-os/sdk/schema").AuthoredPropertyProjection<"plain" | "revisioned", "plain" | "revisioned", true, "deploymentMode", "self"> | import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string, string, false, "deploymentReceipt", "self"> | import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string, string, false, "digest", "self"> | import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string, string, false, "error", "self"> | import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string, string, true, "providerKey", "self"> | import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string, string, true, "providerName", "self"> | import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string, string, false, "revision", "self"> | import("@astrale-os/sdk/schema").AuthoredPropertyProjection<"deploying" | "failed" | "ready", "deploying" | "failed" | "ready", true, "state", "self"> | import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string, string, false, "url", "self">) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+                readonly name: "description";
+                readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
+            }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                readonly name: "createdAt";
+                readonly key: "kernel.astrale.ai:class.Timestamped.property.createdAt";
+            }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                readonly name: "name";
+                readonly key: "kernel.astrale.ai:class.Named.property.name";
+            }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+                readonly name: "updatedAt";
+                readonly key: "kernel.astrale.ai:class.Timestamped.property.updatedAt";
+            });
+            readonly effectiveInstanceMethods: import("@astrale-os/sdk/schema").AuthoredMethodProjection<import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: string[];
+            }, "authenticated", false, "default">>, "schedules", "self"> | import("@astrale-os/sdk/schema").AuthoredMethodProjection<import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: string[];
+            }, "authenticated", false, "default">>, "secrets", "self"> | import("@astrale-os/sdk/schema").AuthoredMethodProjection<import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: {
+                    ok: true;
+                };
+            }, "authenticated", false, "default">>, "delete", "self"> | import("@astrale-os/sdk/schema").AuthoredMethodProjection<import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                name: string;
+                value: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    name: string;
+                };
+            }, "authenticated", false, "default">>, "setSecret", "self"> | import("@astrale-os/sdk/schema").AuthoredMethodProjection<import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                name: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    ok: true;
+                };
+            }, "authenticated", false, "default">>, "deleteSecret", "self"> | import("@astrale-os/sdk/schema").AuthoredMethodProjection<import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                crons: string[];
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    crons: string[];
+                };
+            }, "authenticated", false, "default">>, "setSchedule", "self"> | import("@astrale-os/sdk/schema").AuthoredMethodProjection<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;
+                }[];
+            }, "authenticated", false, "default">>, "logs", "self">;
+            readonly effectiveStaticMethods: import("@astrale-os/sdk/schema").AuthoredMethodProjection<import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                path: string;
+                name?: string | undefined;
+                entry?: string | undefined;
+                modules?: ({
+                    contentBase64: string;
+                    name: string;
+                    kind?: "data" | "esm" | "text" | "wasm" | undefined;
+                } | {
+                    contentBase64Chunks: string[];
+                    name: string;
+                    kind?: "data" | "esm" | "text" | "wasm" | undefined;
+                })[] | undefined;
+                revisioned?: {
+                    revision: string;
+                    release: {
+                        entry: string;
+                        modules: ({
+                            contentBase64: string;
+                            name: string;
+                            kind?: "data" | "esm" | "text" | "wasm" | undefined;
+                        } | {
+                            contentBase64Chunks: string[];
+                            name: string;
+                            kind?: "data" | "esm" | "text" | "wasm" | undefined;
+                        })[];
+                    };
+                    gateway: {
+                        entry: string;
+                        modules: ({
+                            contentBase64: string;
+                            name: string;
+                            kind?: "data" | "esm" | "text" | "wasm" | undefined;
+                        } | {
+                            contentBase64Chunks: string[];
+                            name: string;
+                            kind?: "data" | "esm" | "text" | "wasm" | 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: ({
+                        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;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    path: string;
+                    url: string;
+                    digest: string;
+                    revision?: string | undefined;
+                    state: "deploying" | "failed" | "ready";
+                    error?: string | null | undefined;
+                    functions: {
+                        id: string;
+                        path: string;
+                        ref: string;
+                    }[];
+                };
+            }, "authenticated", true, "default">>, "deploy", "self">;
+        }>;
+        readonly service_owned_by: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "owner";
+                readonly outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "service";
+                readonly incoming: "1";
+            };
+            readonly constraints: Record<never, never>;
+            readonly effectiveProperties: never;
+        }>;
+    };
+    readonly policies: {
+        readonly ObserveService: import("@astrale-os/sdk/schema").Policy;
+        readonly TraverseOwnedService: import("@astrale-os/sdk/schema").Policy;
+    };
+    readonly functions: {
+        readonly listServices: import("@astrale-os/sdk/schema").Function<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+            readonly mode: 'value';
+            readonly value: {
+                id: string;
+                name: string;
+                description: string;
+                providerName: string;
+                coordinate: string;
+                url?: string | undefined;
+                state: "deploying" | "failed" | "ready";
+                digest?: string | undefined;
+                revision?: string | undefined;
+                error?: string | undefined;
+            }[];
+        }, "authenticated", false, "default">>;
+    };
+    readonly views: {
+        application: import("@astrale-os/sdk/schema").View;
+    };
+}>>;
+export type ServicesSchema = typeof schema;
+export type ServicesDomain = language.DomainOf<typeof schema>;

package/dist/schema/application/index.js

@@ -0,0 +1,10 @@
+import { KernelSchema, defineSchema, view } from '@astrale-os/sdk/schema';
+import { CloudflareWorker, ObserveService, TraverseOwnedService, service_owned_by, } from '#schema/service';
+import { listServices } from './functions.js';
+export const schema = defineSchema('services.astrale.ai', {
+    dependencies: { kernel: KernelSchema },
+    classes: { CloudflareWorker, service_owned_by },
+    policies: { ObserveService, TraverseOwnedService },
+    functions: { listServices },
+    views: { application: view({}) },
+});

package/dist/schema/deployment/asset.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export declare const assetFile: z.ZodUnion<readonly [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>]>;
+export declare const assetBundle: z.ZodObject<{
+    files: z.ZodArray<z.ZodUnion<readonly [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>;
+export type AssetBundle = z.infer<typeof assetBundle>;

package/dist/schema/deployment/asset.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { encodedContent, MAX_ASSET_BASE64_SIZE } from './content.js';
+const fields = {
+    path: z.string().min(1).max(2_048),
+    contentType: z.string().min(1).max(256).optional(),
+};
+const content = encodedContent(MAX_ASSET_BASE64_SIZE);
+export const assetFile = z.union([
+    z.strictObject({ ...fields, ...content.inline }),
+    z.strictObject({ ...fields, ...content.chunked }),
+]);
+export const assetBundle = z.strictObject({
+    files: z.array(assetFile).min(1).max(2_000),
+    notFound: z.enum(['none', '404-page', 'single-page-application']).optional(),
+    runWorkerFirst: z.boolean().optional(),
+    htmlHandling: z.literal('none').optional(),
+});

package/dist/schema/deployment/content.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+export declare const PORTABLE_BASE64_CHUNK_SIZE: number;
+export declare const MAX_MODULE_BASE64_SIZE: number;
+export declare const MAX_ASSET_BASE64_SIZE: number;
+export declare function encodedContent(maximumSize: number): Readonly<{
+    inline: {
+        contentBase64: z.ZodString;
+    };
+    chunked: {
+        contentBase64Chunks: z.ZodArray<z.ZodString>;
+    };
+}>;

package/dist/schema/deployment/content.js

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+export const PORTABLE_BASE64_CHUNK_SIZE = 512 * 1024;
+export const MAX_MODULE_BASE64_SIZE = 10 * 1024 * 1024;
+export const MAX_ASSET_BASE64_SIZE = 16 * 1024 * 1024;
+export function encodedContent(maximumSize) {
+    return Object.freeze({
+        inline: { contentBase64: z.string().max(maximumSize) },
+        chunked: {
+            contentBase64Chunks: z
+                .array(z.string().min(1).max(PORTABLE_BASE64_CHUNK_SIZE))
+                .min(1)
+                .max(Math.ceil(maximumSize / PORTABLE_BASE64_CHUNK_SIZE)),
+        },
+    });
+}

package/dist/schema/deployment/index.d.ts

@@ -0,0 +1,11 @@
+export { assetBundle, assetFile } from './asset.js';
+export type { AssetBundle } from './asset.js';
+export { MAX_ASSET_BASE64_SIZE, MAX_MODULE_BASE64_SIZE, PORTABLE_BASE64_CHUNK_SIZE, } from './content.js';
+export { resourceLimits } from './limits.js';
+export type { ResourceLimits } from './limits.js';
+export { artifactModule } from './module.js';
+export type { ArtifactModule } from './module.js';
+export { artifact, deployServiceInput, revisionedDeployment } from './request.js';
+export type { DeployServiceInput } from './request.js';
+export { deployedFunction, deployServiceOutput } from './result.js';
+export type { DeployServiceOutput } from './result.js';

package/dist/schema/deployment/index.js

@@ -0,0 +1,6 @@
+export { assetBundle, assetFile } from './asset.js';
+export { MAX_ASSET_BASE64_SIZE, MAX_MODULE_BASE64_SIZE, PORTABLE_BASE64_CHUNK_SIZE, } from './content.js';
+export { resourceLimits } from './limits.js';
+export { artifactModule } from './module.js';
+export { artifact, deployServiceInput, revisionedDeployment } from './request.js';
+export { deployedFunction, deployServiceOutput } from './result.js';

package/dist/schema/deployment/limits.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export declare const resourceLimits: z.ZodOptional<z.ZodObject<{
+    cpuMs: z.ZodOptional<z.ZodNumber>;
+    subrequests: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>>;
+export type ResourceLimits = Exclude<z.infer<typeof resourceLimits>, undefined>;

package/dist/schema/deployment/limits.js

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+export const resourceLimits = z
+    .strictObject({
+    cpuMs: z.number().int().positive().max(300_000).optional(),
+    subrequests: z.number().int().positive().max(10_000).optional(),
+})
+    .optional();

package/dist/schema/deployment/module.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+export declare const artifactModule: z.ZodUnion<readonly [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>]>;
+export type ArtifactModule = z.infer<typeof artifactModule>;

package/dist/schema/deployment/module.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { encodedContent, MAX_MODULE_BASE64_SIZE } from './content.js';
+const fields = {
+    name: z.string().min(1).max(256),
+    kind: z.enum(['esm', 'wasm', 'text', 'data']).optional(),
+};
+const content = encodedContent(MAX_MODULE_BASE64_SIZE);
+export const artifactModule = z.union([
+    z.strictObject({ ...fields, ...content.inline }),
+    z.strictObject({ ...fields, ...content.chunked }),
+]);