@astrale-domains/services 0.4.4 → 0.4.6

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

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

package/dist/schema/modules/service/index.d.ts

@@ -3,5 +3,5 @@ export { deleteService, deleteServiceSecret, deployCloudflareWorker, listService
 export { OwnService, TraverseOwnedService } from './policies/index.js';
 export { serviceLifecycle } from './states/index.js';
 export type { ServiceLifecycle, ServiceLifecycleEvent } from './states/index.js';
-export { artifact, artifactModule, assetBundle, assetFile, deployedService, deploymentRejection, deployServiceInput, deployServiceOutput, resourceLimits, revisionedDeployment, PORTABLE_BASE64_CHUNK_SIZE, } from './types/index.js';
-export type { ArtifactModule, AssetBundle, DeployServiceInput, DeployServiceOutput, ResourceLimits, } from './types/index.js';
+export { artifact, artifactModule, assetBundle, assetFile, deployedService, deploymentRejection, deployServiceInput, deployServiceOutput, resourceLimits, revisionedDeployment, PORTABLE_BASE64_CHUNK_SIZE, MAX_ASSET_DECODED_SIZE, MAX_DEPLOYMENT_DECODED_SIZE, MAX_MODULE_DECODED_SIZE, } from './types/index.js';
+export type { ArtifactModule, AssetBundle, DeployServiceInput, DeployServiceOutput, ResourceLimits, ServiceDeploymentContent, } from './types/index.js';

package/dist/schema/modules/service/index.js

@@ -2,4 +2,4 @@ export { CloudflareWorker, Service, service_owned_by } from './classes/index.js'
 export { deleteService, deleteServiceSecret, deployCloudflareWorker, listServiceLogs, listServiceSchedules, listServiceSecretNames, replaceServiceSchedules, setServiceSecret, } from './functions/index.js';
 export { OwnService, TraverseOwnedService } from './policies/index.js';
 export { serviceLifecycle } from './states/index.js';
-export { artifact, artifactModule, assetBundle, assetFile, deployedService, deploymentRejection, deployServiceInput, deployServiceOutput, resourceLimits, revisionedDeployment, PORTABLE_BASE64_CHUNK_SIZE, } from './types/index.js';
+export { artifact, artifactModule, assetBundle, assetFile, deployedService, deploymentRejection, deployServiceInput, deployServiceOutput, resourceLimits, revisionedDeployment, PORTABLE_BASE64_CHUNK_SIZE, MAX_ASSET_DECODED_SIZE, MAX_DEPLOYMENT_DECODED_SIZE, MAX_MODULE_DECODED_SIZE, } from './types/index.js';

package/dist/schema/modules/service/types/content/index.d.ts

@@ -0,0 +1 @@
+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 './limits.js';

package/dist/schema/modules/service/types/content/index.js

@@ -0,0 +1 @@
+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 './limits.js';

package/dist/schema/modules/service/types/content/limits.d.ts

@@ -0,0 +1,7 @@
+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 const MAX_MODULE_DECODED_SIZE: number;
+export declare const MAX_ASSET_DECODED_SIZE: number;
+/** Bound retained deployment material independently of its compressed request size. */
+export declare const MAX_DEPLOYMENT_DECODED_SIZE: number;

package/dist/schema/modules/service/types/content/limits.js

@@ -0,0 +1,7 @@
+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 const MAX_MODULE_DECODED_SIZE = (MAX_MODULE_BASE64_SIZE / 4) * 3;
+export const MAX_ASSET_DECODED_SIZE = (MAX_ASSET_BASE64_SIZE / 4) * 3;
+/** Bound retained deployment material independently of its compressed request size. */
+export const MAX_DEPLOYMENT_DECODED_SIZE = 32 * 1024 * 1024;

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

@@ -2,6 +2,29 @@ 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<{
@@ -26,6 +49,29 @@ export declare const revisionedDeployment: z.ZodObject<{
     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<{
@@ -54,6 +100,29 @@ 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<{
@@ -77,6 +146,29 @@ export declare const deployServiceInput: z.ZodObject<{
         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<{
@@ -111,6 +203,24 @@ export declare const deployServiceInput: z.ZodObject<{
     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>;

package/dist/schema/modules/service/types/index.d.ts

@@ -4,10 +4,11 @@ export { artifactModule } from './service-deployment-artifact-module.js';
 export type { ArtifactModule } from './service-deployment-artifact-module.js';
 export { assetBundle, assetFile } from './service-deployment-assets.js';
 export type { AssetBundle } from './service-deployment-assets.js';
-export { MAX_ASSET_BASE64_SIZE, MAX_MODULE_BASE64_SIZE, PORTABLE_BASE64_CHUNK_SIZE, } from './service-deployment-content.js';
+export { MAX_ASSET_DECODED_SIZE, MAX_DEPLOYMENT_DECODED_SIZE, MAX_MODULE_DECODED_SIZE, MAX_ASSET_BASE64_SIZE, MAX_MODULE_BASE64_SIZE, PORTABLE_BASE64_CHUNK_SIZE, } from './service-deployment-content.js';
 export { resourceLimits } from './service-deployment-resource-limits.js';
 export type { ResourceLimits } from './service-deployment-resource-limits.js';
 export { secretName } from './service-secret-name.js';
 export { secretOperationRejection } from './service-secret-operation-rejection.js';
 export { serviceReadiness } from './service-readiness.js';
 export { setServiceSecretContract, deleteServiceSecretContract, listServiceSecretNamesContract, replaceServiceSchedulesContract, listServiceSchedulesContract, listServiceLogsContract, deleteServiceContract, } from './service-management.js';
+export type { ServiceDeploymentContent } from './service-deployment-content.js';

package/dist/schema/modules/service/types/index.js

@@ -1,7 +1,7 @@
 export { artifact, deployedService, deploymentRejection, deployServiceInput, deployServiceOutput, revisionedDeployment, } from './deploy-cloudflare-worker.js';
 export { artifactModule } from './service-deployment-artifact-module.js';
 export { assetBundle, assetFile } from './service-deployment-assets.js';
-export { MAX_ASSET_BASE64_SIZE, MAX_MODULE_BASE64_SIZE, PORTABLE_BASE64_CHUNK_SIZE, } from './service-deployment-content.js';
+export { MAX_ASSET_DECODED_SIZE, MAX_DEPLOYMENT_DECODED_SIZE, MAX_MODULE_DECODED_SIZE, MAX_ASSET_BASE64_SIZE, MAX_MODULE_BASE64_SIZE, PORTABLE_BASE64_CHUNK_SIZE, } from './service-deployment-content.js';
 export { resourceLimits } from './service-deployment-resource-limits.js';
 export { secretName } from './service-secret-name.js';
 export { secretOperationRejection } from './service-secret-operation-rejection.js';

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

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { PORTABLE_BASE64_CHUNK_SIZE } from '../content/index.js';
+/** @deprecated Send the content envelope instead. Retained for deployed SDK clients. */
+export function legacyEncodedContent(maximumSize) {
+    return Object.freeze({
+        inline: { contentBase64: z.string().max(maximumSize).meta({ deprecated: true }) },
+        chunked: {
+            contentBase64Chunks: z
+                .array(z.string().min(1).max(PORTABLE_BASE64_CHUNK_SIZE))
+                .min(1)
+                .max(Math.ceil(maximumSize / PORTABLE_BASE64_CHUNK_SIZE))
+                .meta({ deprecated: true }),
+        },
+    });
+}

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

@@ -1,5 +1,28 @@
 import { z } from 'zod';
 export declare const artifactModule: 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<{

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

@@ -1,11 +1,13 @@
 import { z } from 'zod';
+import { legacyEncodedContent } from './legacy/service-deployment-content.js';
 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(),
 };
-const content = encodedContent(MAX_MODULE_BASE64_SIZE);
+const legacy = legacyEncodedContent(MAX_MODULE_BASE64_SIZE);
 export const artifactModule = z.union([
-    z.strictObject({ ...fields, ...content.inline }),
-    z.strictObject({ ...fields, ...content.chunked }),
+    z.strictObject({ ...fields, content: encodedContent(MAX_MODULE_BASE64_SIZE) }),
+    z.strictObject({ ...fields, ...legacy.inline }),
+    z.strictObject({ ...fields, ...legacy.chunked }),
 ]);

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

@@ -1,5 +1,23 @@
 import { z } from 'zod';
 export declare const assetFile: 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>;
@@ -10,6 +28,24 @@ export declare const assetFile: z.ZodUnion<readonly [z.ZodObject<{
 }, z.core.$strict>]>;
 export declare const assetBundle: 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>;

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

@@ -1,13 +1,15 @@
 import { z } from 'zod';
+import { legacyEncodedContent } from './legacy/service-deployment-content.js';
 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(),
 };
-const content = encodedContent(MAX_ASSET_BASE64_SIZE);
+const legacy = legacyEncodedContent(MAX_ASSET_BASE64_SIZE);
 export const assetFile = z.union([
-    z.strictObject({ ...fields, ...content.inline }),
-    z.strictObject({ ...fields, ...content.chunked }),
+    z.strictObject({ ...fields, content: encodedContent(MAX_ASSET_BASE64_SIZE) }),
+    z.strictObject({ ...fields, ...legacy.inline }),
+    z.strictObject({ ...fields, ...legacy.chunked }),
 ]);
 export const assetBundle = z.strictObject({
     files: z.array(assetFile).min(1).max(2_000),

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

@@ -1,12 +1,19 @@
 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>;
-    };
-}>;
+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/service/types/service-deployment-content.js

@@ -1,15 +1,24 @@
 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;
+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) {
-    return Object.freeze({
-        inline: { contentBase64: z.string().max(maximumSize) },
-        chunked: {
+    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)),
-        },
-    });
+        }),
+    ]);
 }