@astrale-domains/services 0.5.1 → 0.7.0

package/dist/schema/modules/deployment/types/frozen-configuration.d.ts

@@ -1,52 +0,0 @@
-import { z } from 'zod';
-/**
- * The `FrozenConfigurationV1` (`@astrale-os/sdk/deployment/address`) one deployment freezes beside
- * its build: the author's plain variables, the execution settings and the durable Workflow options
- * it declares, the runtime, the services and dispatch namespaces it binds and the names of the
- * secrets it binds, never their values. Its digest and the build digest make the deployment's
- * address. This shape only bounds what a request and the graph carry; the SDK's
- * `configurationDigest` admits its canonical form, and a hosted deployment's admission decides
- * which bindings Services hosts (`acceptDeploymentRequest`).
- */
-export declare const frozenConfiguration: z.ZodObject<{
-    format: z.ZodLiteral<"astrale.deployment.configuration">;
-    version: z.ZodLiteral<1>;
-    vars: z.ZodRecord<z.ZodString, z.ZodString>;
-    settings: z.ZodObject<{
-        maximumRequestBytes: z.ZodNumber;
-        invocationTimeoutMs: z.ZodNumber;
-        tokenExchange: z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodObject<{
-            maximumLifetimeSeconds: z.ZodNumber;
-        }, z.core.$strict>]>;
-        durableOptions: z.ZodOptional<z.ZodObject<{
-            retentionMs: z.ZodOptional<z.ZodNumber>;
-            retry: z.ZodOptional<z.ZodObject<{
-                initialIntervalMs: z.ZodOptional<z.ZodNumber>;
-                maxAttempts: z.ZodOptional<z.ZodNumber>;
-                maxIntervalMs: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strict>>;
-            stepTimeoutMs: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>;
-    runtime: z.ZodObject<{
-        compatibilityDate: z.ZodString;
-        compatibilityFlags: z.ZodArray<z.ZodString>;
-    }, z.core.$strict>;
-    bindings: z.ZodObject<{
-        services: z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            service: z.ZodString;
-        }, z.core.$strict>>;
-        dispatchNamespaces: z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            namespace: z.ZodString;
-        }, z.core.$strict>>;
-        secrets: z.ZodArray<z.ZodString>;
-    }, z.core.$strict>;
-    router: z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodObject<{
-        service: z.ZodString;
-        hostSuffix: z.ZodString;
-        minLabels: z.ZodNumber;
-    }, z.core.$strict>]>;
-}, z.core.$strict>;
-export type FrozenConfiguration = z.output<typeof frozenConfiguration>;

package/dist/schema/modules/deployment/types/frozen-configuration.js

@@ -1,55 +0,0 @@
-import { z } from 'zod';
-const name = z.string().min(1).max(128);
-const positive = z.number().int().min(1);
-/**
- * The `FrozenConfigurationV1` (`@astrale-os/sdk/deployment/address`) one deployment freezes beside
- * its build: the author's plain variables, the execution settings and the durable Workflow options
- * it declares, the runtime, the services and dispatch namespaces it binds and the names of the
- * secrets it binds, never their values. Its digest and the build digest make the deployment's
- * address. This shape only bounds what a request and the graph carry; the SDK's
- * `configurationDigest` admits its canonical form, and a hosted deployment's admission decides
- * which bindings Services hosts (`acceptDeploymentRequest`).
- */
-export const frozenConfiguration = z.strictObject({
-    format: z.literal('astrale.deployment.configuration'),
-    version: z.literal(1),
-    vars: z.record(name, z.string().max(64 * 1024)),
-    settings: z.strictObject({
-        maximumRequestBytes: z.number().int().min(1),
-        invocationTimeoutMs: z.number().int().min(1),
-        tokenExchange: z.union([
-            z.literal(false),
-            z.strictObject({ maximumLifetimeSeconds: z.number().int().min(1) }),
-        ]),
-        durableOptions: z
-            .strictObject({
-            retentionMs: positive.optional(),
-            retry: z
-                .strictObject({
-                initialIntervalMs: positive.optional(),
-                maxAttempts: positive.optional(),
-                maxIntervalMs: positive.optional(),
-            })
-                .optional(),
-            stepTimeoutMs: positive.optional(),
-        })
-            .optional(),
-    }),
-    runtime: z.strictObject({
-        compatibilityDate: z.string().min(1).max(32),
-        compatibilityFlags: z.array(name).max(64),
-    }),
-    bindings: z.strictObject({
-        services: z.array(z.strictObject({ name, service: name })).max(32),
-        dispatchNamespaces: z.array(z.strictObject({ name, namespace: name })).max(32),
-        secrets: z.array(name).max(64),
-    }),
-    router: z.union([
-        z.literal(false),
-        z.strictObject({
-            service: name,
-            hostSuffix: z.string().max(253),
-            minLabels: z.number().int().min(0).max(127),
-        }),
-    ]),
-});

package/dist/schema/modules/deployment/types/service-deployment-artifact-module.d.ts

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

package/dist/schema/modules/deployment/types/service-deployment-artifact-module.js

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

package/dist/schema/modules/deployment/types/service-deployment-assets.d.ts

@@ -1,49 +0,0 @@
-import { z } from 'zod';
-export declare const assetFile: 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>;
-export declare const assetBundle: z.ZodObject<{
-    files: z.ZodArray<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>>;
-    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/modules/deployment/types/service-deployment-assets.js

@@ -1,16 +0,0 @@
-import { z } from 'zod';
-import { encodedContent, MAX_ASSET_BASE64_SIZE } from './service-deployment-content.js';
-const fields = {
-    path: z.string().min(1).max(2_048),
-    contentType: z.string().min(1).max(256).optional(),
-};
-export const assetFile = z.strictObject({
-    ...fields,
-    content: encodedContent(MAX_ASSET_BASE64_SIZE),
-});
-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/modules/deployment/types/service-deployment-content.d.ts

@@ -1,19 +0,0 @@
-import { z } from 'zod';
-export { PORTABLE_BASE64_CHUNK_SIZE, MAX_MODULE_BASE64_SIZE, MAX_ASSET_BASE64_SIZE, MAX_MODULE_DECODED_SIZE, MAX_ASSET_DECODED_SIZE, MAX_DEPLOYMENT_DECODED_SIZE, } from './content/index.js';
-/** Encoding is transport evidence; release identity always describes decoded bytes. */
-export declare function encodedContent(maximumSize: number): 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>]>;
-export type ServiceDeploymentContent = z.infer<ReturnType<typeof encodedContent>>;

package/dist/schema/modules/deployment/types/service-deployment-content.js

@@ -1,24 +0,0 @@
-import { z } from 'zod';
-import { PORTABLE_BASE64_CHUNK_SIZE } from './content/index.js';
-export { PORTABLE_BASE64_CHUNK_SIZE, MAX_MODULE_BASE64_SIZE, MAX_ASSET_BASE64_SIZE, MAX_MODULE_DECODED_SIZE, MAX_ASSET_DECODED_SIZE, MAX_DEPLOYMENT_DECODED_SIZE, } from './content/index.js';
-/** Encoding is transport evidence; release identity always describes decoded bytes. */
-export function encodedContent(maximumSize) {
-    const fields = {
-        encoding: z.enum(['identity', 'gzip']),
-        decodedSize: z
-            .number()
-            .int()
-            .min(0)
-            .max((maximumSize / 4) * 3),
-    };
-    return z.union([
-        z.strictObject({ ...fields, contentBase64: z.string().max(maximumSize) }),
-        z.strictObject({
-            ...fields,
-            contentBase64Chunks: z
-                .array(z.string().min(1).max(PORTABLE_BASE64_CHUNK_SIZE))
-                .min(1)
-                .max(Math.ceil(maximumSize / PORTABLE_BASE64_CHUNK_SIZE)),
-        }),
-    ]);
-}