@astrale-domains/services 0.4.5 → 0.4.7

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

@@ -2,6 +2,18 @@ export declare const deployCloudflareWorker: import("@astrale-os/sdk/schema").Me
     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;
@@ -15,6 +27,18 @@ export declare const deployCloudflareWorker: import("@astrale-os/sdk/schema").Me
         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;
@@ -39,6 +63,18 @@ export declare const deployCloudflareWorker: import("@astrale-os/sdk/schema").Me
     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;
@@ -70,4 +106,4 @@ export declare const deployCloudflareWorker: import("@astrale-os/sdk/schema").Me
         reason: "artifact-mode-conflict" | "invalid-deployment" | "service-unavailable";
         message: string;
     };
-}, "authenticated", true, false>>;
+}, "authenticated", true, false, undefined>>;

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

@@ -9,4 +9,4 @@ export declare const listServiceLogs: import("@astrale-os/sdk/schema").Method<im
         level: string;
         line: string;
     }[];
-}, "authorized", false, true>>;
+}, "authorized", false, true, undefined>>;

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

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

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

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

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

@@ -9,4 +9,4 @@ export declare const listWorkerLogs: import("@astrale-os/sdk/schema").Method<imp
         level: string;
         line: string;
     }[];
-}, "authorized", false, false>>;
+}, "authorized", false, false, undefined>>;

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

@@ -1,4 +1,4 @@
 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>>;
+}, "authorized", false, false, undefined>>;

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

@@ -1,4 +1,4 @@
 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>>;
+}, "authorized", false, false, undefined>>;

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

@@ -21,4 +21,4 @@ export declare const migrateWorkerIngress: import("@astrale-os/sdk/schema").Meth
         kind: "rejected";
         reason: "missing-location" | "not-detached" | "service-unavailable";
     };
-}, "authorized", false, false>>;
+}, "authorized", false, false, undefined>>;

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

@@ -8,4 +8,4 @@ export declare const replaceServiceSchedules: import("@astrale-os/sdk/schema").M
         kind: "rejected";
         reason: "invalid-schedule" | "service-unavailable";
     };
-}, "authorized", false, true>>;
+}, "authorized", false, true, undefined>>;

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

@@ -8,4 +8,4 @@ export declare const replaceWorkerSchedules: import("@astrale-os/sdk/schema").Me
         kind: "rejected";
         reason: "invalid-schedule" | "service-unavailable";
     };
-}, "authorized", false, false>>;
+}, "authorized", false, false, undefined>>;

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

@@ -9,4 +9,4 @@ export declare const setServiceSecret: import("@astrale-os/sdk/schema").Method<i
     } | {
         name: string;
     };
-}, "authorized", false, true>>;
+}, "authorized", false, true, undefined>>;

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,22 @@
+import { z } from 'zod';
+import { PORTABLE_BASE64_CHUNK_SIZE } from '../content/index.js';
+/**
+ * Flat portable Base64 module and asset content, the form adapter-astrale ≤ 0.5.0-beta.157 sends.
+ * The `DeploymentContent` envelope (`identity` or `gzip`) is the canonical form; every deploy
+ * request, the Admin-hosted `CloudflareDeployment.deploy` included, decodes both to the same bytes
+ * (AM-176). Remove when no supported adapter-astrale is older than 0.5.0-beta.158.
+ *
+ * @deprecated Send the content envelope instead.
+ */
+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)),
-        },
-    });
+        }),
+    ]);
 }