@astrale-domains/services 0.4.4 → 0.4.6

package/dist/schema/modules/deployment/classes/deployment-line.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+/**
+ * The line every deployment of one origin in one environment shares. The first organisation that
+ * deploys on it holds it, and only an operator transfer gives it to another: it stays registered
+ * and refused to every other organisation after its organisation, that organisation's Services or
+ * every deployment on it are deleted.
+ */
+export declare const DeploymentLine: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+    readonly description: "The deployment line of one origin in one environment, held by one organisation.";
+    readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+    readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Timestamped">];
+    readonly properties: {
+        origin: z.ZodString;
+        environment: z.ZodString;
+        /** The 16-character fingerprint of `(origin, environment)`; it alone identifies the line. */
+        fingerprint: z.ZodString;
+        /** How the line reads in its deployments' labels: readable, or the fingerprint alone. */
+        line: z.ZodString;
+    };
+    readonly policies: {
+        read: () => import("@astrale-os/sdk/schema").Policy;
+    };
+}>;

package/dist/schema/modules/deployment/classes/deployment-line.js

@@ -0,0 +1,24 @@
+import { classIcon, fullMatch, K, nodeClass } from '@astrale-os/sdk/schema';
+import { GitBranch } from '@astrale-os/sdk/schema/icons';
+import { z } from 'zod';
+import { OwnLine } from '../policies/own-line.js';
+/**
+ * The line every deployment of one origin in one environment shares. The first organisation that
+ * deploys on it holds it, and only an operator transfer gives it to another: it stays registered
+ * and refused to every other organisation after its organisation, that organisation's Services or
+ * every deployment on it are deleted.
+ */
+export const DeploymentLine = nodeClass({
+    description: 'The deployment line of one origin in one environment, held by one organisation.',
+    icon: classIcon.lucide(GitBranch),
+    extends: [K.classes.Timestamped],
+    properties: {
+        origin: z.string().min(1).max(253),
+        environment: z.string().min(1).max(63),
+        /** The 16-character fingerprint of `(origin, environment)`; it alone identifies the line. */
+        fingerprint: z.string().check(fullMatch('[a-z2-7]{16}')),
+        /** How the line reads in its deployments' labels: readable, or the fingerprint alone. */
+        line: z.string().min(16).max(40),
+    },
+    policies: { read: () => OwnLine },
+});

package/dist/schema/modules/deployment/classes/deployment-on-line.d.ts

@@ -0,0 +1,17 @@
+/** The line one deployment was made on; a deployment never moves to another line. */
+export declare const deployment_on_line: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+    readonly depth: 0;
+    readonly abstract: false;
+    readonly extends: readonly [];
+    readonly properties: never;
+    readonly source: {
+        readonly as: "deployment";
+        readonly outgoing: "1";
+    };
+    readonly target: {
+        readonly as: "line";
+        readonly incoming: "0..*";
+    };
+    readonly constraints: Record<never, never>;
+    readonly effectiveProperties: never;
+}>;

package/dist/schema/modules/deployment/classes/deployment-on-line.js

@@ -0,0 +1,11 @@
+import { edgeClass } from '@astrale-os/sdk/schema';
+import { TraverseOwnedLineDeployment } from '../policies/traverse-owned-line-deployment.js';
+import { DeploymentLine } from './deployment-line.js';
+import { Deployment } from './deployment.js';
+/** The line one deployment was made on; a deployment never moves to another line. */
+export const deployment_on_line = edgeClass.directed({
+    description: 'The deployment line one Deployment belongs to.',
+    source: { as: 'deployment', accepts: [() => Deployment], outgoing: '1' },
+    target: { as: 'line', accepts: [() => DeploymentLine], incoming: '0..*' },
+    policies: { traverse: () => TraverseOwnedLineDeployment },
+});

package/dist/schema/modules/deployment/classes/deployment.d.ts

@@ -0,0 +1,98 @@
+import { z } from 'zod';
+/**
+ * One immutable deployment of a release: one build in one environment with its frozen
+ * configuration, served by one script at its own URL. It never changes code; a new release is a
+ * new deployment on the same line.
+ */
+export declare const Deployment: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+    readonly abstract: true;
+    readonly description: "One immutable deployment of a release on a publisher line.";
+    readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+    readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Timestamped">];
+    readonly properties: {
+        /** `<line>-<content16>`, the DNS label and provider script name of this deployment. */
+        label: z.ZodString;
+        url: z.ZodString;
+        state: import("@astrale-os/sdk/schema").StateProperty<import("@astrale-os/sdk/schema").StateMachine<{
+            readonly deploying: {
+                readonly activate: "active";
+                readonly fail: "failed";
+            };
+            readonly active: {
+                readonly retire: "retiring";
+            };
+            readonly retiring: {
+                readonly completeRetirement: "retired";
+            };
+            readonly retired: {
+                readonly revive: "deploying";
+            };
+            readonly failed: {
+                readonly retry: "deploying";
+            };
+        }, "deploying">, {
+            required?: boolean;
+            description?: string;
+        }>;
+        retention: z.ZodEnum<{
+            preview: "preview";
+            published: "published";
+        }>;
+        record: z.ZodObject<{
+            format: z.ZodLiteral<"astrale.deployment-record">;
+            version: z.ZodLiteral<1>;
+            origin: z.ZodString;
+            environment: z.ZodString;
+            releaseDigest: z.ZodString;
+            buildDigest: z.ZodString;
+            schemaRevision: z.ZodString;
+            configuration: z.ZodString;
+            providerScript: z.ZodString;
+            commit: z.ZodNullable<z.ZodObject<{
+                sha: z.ZodString;
+                dirty: z.ZodBoolean;
+                base: z.ZodOptional<z.ZodObject<{
+                    version: z.ZodString;
+                    distance: z.ZodNumber;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        signingKeyId: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodString, {
+            readonly required: false;
+        }>;
+        lastCallAt: import("@astrale-os/sdk/schema").AuthoredProperty<Readonly<{
+            readonly type: 'string';
+            readonly 'x-astrale-value-kind': 'instant';
+        }>, {
+            readonly required: false;
+        }>;
+        expiresAt: import("@astrale-os/sdk/schema").AuthoredProperty<Readonly<{
+            readonly type: 'string';
+            readonly 'x-astrale-value-kind': 'instant';
+        }>, {
+            readonly required: false;
+        }>;
+        retiredAt: import("@astrale-os/sdk/schema").AuthoredProperty<Readonly<{
+            readonly type: 'string';
+            readonly 'x-astrale-value-kind': 'instant';
+        }>, {
+            readonly required: false;
+        }>;
+        retirement: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodEnum<{
+            expired: "expired";
+            withdrawn: "withdrawn";
+        }>, {
+            readonly required: false;
+        }>;
+        /** The graph lease of the provider operation in flight on this deployment. */
+        operationReceipt: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodString, {
+            readonly required: false;
+        }>;
+        operationExpiresAt: import("@astrale-os/sdk/schema").AuthoredProperty<Readonly<{
+            readonly type: 'string';
+            readonly 'x-astrale-value-kind': 'instant';
+        }>, {
+            readonly required: false;
+        }>;
+    };
+}>;

package/dist/schema/modules/deployment/classes/deployment.js

@@ -0,0 +1,32 @@
+import { classIcon, K, nodeClass, property, schema as valueSchema, stateProperty, } from '@astrale-os/sdk/schema';
+import { Rocket } from '@astrale-os/sdk/schema/icons';
+import { z } from 'zod';
+import { deploymentLifecycle } from '../states/index.js';
+import { deploymentRecord, deploymentRetention, deploymentRetirement } from '../types/index.js';
+/**
+ * One immutable deployment of a release: one build in one environment with its frozen
+ * configuration, served by one script at its own URL. It never changes code; a new release is a
+ * new deployment on the same line.
+ */
+export const Deployment = nodeClass({
+    abstract: true,
+    description: 'One immutable deployment of a release on a publisher line.',
+    icon: classIcon.lucide(Rocket),
+    extends: [K.classes.Timestamped],
+    properties: {
+        /** `<line>-<content16>`, the DNS label and provider script name of this deployment. */
+        label: z.string().min(33).max(57),
+        url: z.string().min(1).max(2_048),
+        state: stateProperty(deploymentLifecycle),
+        retention: deploymentRetention,
+        record: deploymentRecord,
+        signingKeyId: property(z.string().min(1).max(128), { required: false }),
+        lastCallAt: property(valueSchema.values.instant, { required: false }),
+        expiresAt: property(valueSchema.values.instant, { required: false }),
+        retiredAt: property(valueSchema.values.instant, { required: false }),
+        retirement: property(deploymentRetirement, { required: false }),
+        /** The graph lease of the provider operation in flight on this deployment. */
+        operationReceipt: property(z.string().min(1).max(128), { required: false }),
+        operationExpiresAt: property(valueSchema.values.instant, { required: false }),
+    },
+});

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

@@ -0,0 +1,5 @@
+export { CloudflareDeployment } from './cloudflare-deployment.js';
+export { Deployment } from './deployment.js';
+export { DeploymentLine } from './deployment-line.js';
+export { deployment_on_line } from './deployment-on-line.js';
+export { line_owned_by } from './line-owned-by.js';

package/dist/schema/modules/deployment/classes/index.js

@@ -0,0 +1,5 @@
+export { CloudflareDeployment } from './cloudflare-deployment.js';
+export { Deployment } from './deployment.js';
+export { DeploymentLine } from './deployment-line.js';
+export { deployment_on_line } from './deployment-on-line.js';
+export { line_owned_by } from './line-owned-by.js';

package/dist/schema/modules/deployment/classes/line-owned-by.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The organisation holding one deployment line: an Identity of the Admin instance, a Shell User
+ * or Group, whose members and CI identities act for it through `extends_with`. A line outlives
+ * this Edge: deleting its organisation removes the Edge and leaves the line held by nobody until
+ * an operator transfer.
+ *
+ * Hence at most one holder, not exactly one: the Kernel deletes a Node only together with every
+ * incident Edge, so a required holder would make the organisation undeletable unless its lines
+ * went with it, and a deleted line would free its fingerprint for another organisation.
+ */
+export declare const line_owned_by: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+    readonly depth: 0;
+    readonly abstract: false;
+    readonly extends: readonly [];
+    readonly properties: never;
+    readonly source: {
+        readonly as: "line";
+        readonly outgoing: "0..1";
+    };
+    readonly target: {
+        readonly as: "owner";
+        readonly incoming: "0..*";
+    };
+    readonly constraints: Record<never, never>;
+    readonly effectiveProperties: never;
+}>;

package/dist/schema/modules/deployment/classes/line-owned-by.js

@@ -0,0 +1,19 @@
+import { edgeClass, K } from '@astrale-os/sdk/schema';
+import { TraverseOwnedLine } from '../policies/traverse-owned-line.js';
+import { DeploymentLine } from './deployment-line.js';
+/**
+ * The organisation holding one deployment line: an Identity of the Admin instance, a Shell User
+ * or Group, whose members and CI identities act for it through `extends_with`. A line outlives
+ * this Edge: deleting its organisation removes the Edge and leaves the line held by nobody until
+ * an operator transfer.
+ *
+ * Hence at most one holder, not exactly one: the Kernel deletes a Node only together with every
+ * incident Edge, so a required holder would make the organisation undeletable unless its lines
+ * went with it, and a deleted line would free its fingerprint for another organisation.
+ */
+export const line_owned_by = edgeClass.directed({
+    description: 'The organisation that holds one deployment line.',
+    source: { as: 'line', accepts: [() => DeploymentLine], outgoing: '0..1' },
+    target: { as: 'owner', accepts: [K.classes.Identity], incoming: '0..*' },
+    policies: { traverse: () => TraverseOwnedLine },
+});

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

@@ -0,0 +1,6 @@
+export { CloudflareDeployment, Deployment, DeploymentLine, deployment_on_line, line_owned_by, } from './classes/index.js';
+export { OwnDeployment, OwnLine, TraverseOwnedLine, TraverseOwnedLineDeployment, } from './policies/index.js';
+export { deploymentLifecycle } from './states/index.js';
+export type { DeploymentLifecycle, DeploymentLifecycleEvent } from './states/index.js';
+export { deploymentCommit, deploymentRecord, deploymentRetention, deploymentRetirement, } from './types/index.js';
+export type { DeploymentRecord, DeploymentRetention, DeploymentRetirement } from './types/index.js';

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

@@ -0,0 +1,4 @@
+export { CloudflareDeployment, Deployment, DeploymentLine, deployment_on_line, line_owned_by, } from './classes/index.js';
+export { OwnDeployment, OwnLine, TraverseOwnedLine, TraverseOwnedLineDeployment, } from './policies/index.js';
+export { deploymentLifecycle } from './states/index.js';
+export { deploymentCommit, deploymentRecord, deploymentRetention, deploymentRetirement, } from './types/index.js';

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

@@ -0,0 +1,4 @@
+export { OwnDeployment } from './own-deployment.js';
+export { OwnLine } from './own-line.js';
+export { TraverseOwnedLine } from './traverse-owned-line.js';
+export { TraverseOwnedLineDeployment } from './traverse-owned-line-deployment.js';

package/dist/schema/modules/deployment/policies/index.js

@@ -0,0 +1,4 @@
+export { OwnDeployment } from './own-deployment.js';
+export { OwnLine } from './own-line.js';
+export { TraverseOwnedLine } from './traverse-owned-line.js';
+export { TraverseOwnedLineDeployment } from './traverse-owned-line-deployment.js';

package/dist/schema/modules/deployment/policies/own-deployment.d.ts

@@ -0,0 +1,2 @@
+/** A deployment belongs to whoever holds its line; it carries no owner of its own. */
+export declare const OwnDeployment: import("@astrale-os/sdk/schema").Policy;

package/dist/schema/modules/deployment/policies/own-deployment.js

@@ -0,0 +1,12 @@
+import { policy } from '@astrale-os/sdk/schema';
+import { DeploymentLine } from '../classes/deployment-line.js';
+import { deployment_on_line } from '../classes/deployment-on-line.js';
+import { line_owned_by } from '../classes/line-owned-by.js';
+/** A deployment belongs to whoever holds its line; it carries no owner of its own. */
+export const OwnDeployment = policy({
+    description: 'The subject holds the deployment line this Deployment was made on.',
+    match: ({ allOf, edge, exists, object, subject }) => exists(({ node }) => {
+        const line = node(() => DeploymentLine);
+        return allOf(edge({ source: object, class: () => deployment_on_line, target: line }), edge({ source: line, class: () => line_owned_by, target: subject }));
+    }),
+});

package/dist/schema/modules/deployment/policies/own-line.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The organisation holding a line, and every Identity that acts for it: a member or a CI identity
+ * reaches it through its `extends_with` composition, never through a second rule here.
+ */
+export declare const OwnLine: import("@astrale-os/sdk/schema").Policy;

package/dist/schema/modules/deployment/policies/own-line.js

@@ -0,0 +1,10 @@
+import { policy } from '@astrale-os/sdk/schema';
+import { line_owned_by } from '../classes/line-owned-by.js';
+/**
+ * The organisation holding a line, and every Identity that acts for it: a member or a CI identity
+ * reaches it through its `extends_with` composition, never through a second rule here.
+ */
+export const OwnLine = policy({
+    description: 'The subject holds this deployment line.',
+    match: ({ edge, object, subject }) => edge({ source: object, class: () => line_owned_by, target: subject }),
+});

package/dist/schema/modules/deployment/policies/traverse-owned-line-deployment.d.ts

@@ -0,0 +1,2 @@
+/** A deployment's line relationship is visible only to the holder of that line. */
+export declare const TraverseOwnedLineDeployment: import("@astrale-os/sdk/schema").Policy;

package/dist/schema/modules/deployment/policies/traverse-owned-line-deployment.js

@@ -0,0 +1,7 @@
+import { policy } from '@astrale-os/sdk/schema';
+import { line_owned_by } from '../classes/line-owned-by.js';
+/** A deployment's line relationship is visible only to the holder of that line. */
+export const TraverseOwnedLineDeployment = policy({
+    description: 'The subject holds the deployment line at the target of this relationship.',
+    match: ({ edge, subject, target }) => edge({ source: target, class: () => line_owned_by, target: subject }),
+});

package/dist/schema/modules/deployment/policies/traverse-owned-line.d.ts

@@ -0,0 +1,2 @@
+/** A line's holder relationship is visible only to the holder of that line. */
+export declare const TraverseOwnedLine: import("@astrale-os/sdk/schema").Policy;

package/dist/schema/modules/deployment/policies/traverse-owned-line.js

@@ -0,0 +1,7 @@
+import { policy } from '@astrale-os/sdk/schema';
+import { line_owned_by } from '../classes/line-owned-by.js';
+/** A line's holder relationship is visible only to the holder of that line. */
+export const TraverseOwnedLine = policy({
+    description: 'The subject holds the deployment line at the source of this relationship.',
+    match: ({ edge, source, subject }) => edge({ source, class: () => line_owned_by, target: subject }),
+});

package/dist/schema/modules/deployment/states/deployment-lifecycle.d.ts

@@ -0,0 +1,27 @@
+import { type EventOf, type StateOf } from '@astrale-os/sdk/state';
+/**
+ * Lifecycle of one immutable deployment. A deployment never changes code: it is created
+ * `deploying`, becomes `active` once its script serves, and leaves only by retirement. A failed
+ * creation can be retried on the same label; an expired retirement can be revived for the same
+ * owner and artifact.
+ */
+export declare const deploymentLifecycle: import("@astrale-os/sdk/schema").StateMachine<{
+    readonly deploying: {
+        readonly activate: "active";
+        readonly fail: "failed";
+    };
+    readonly active: {
+        readonly retire: "retiring";
+    };
+    readonly retiring: {
+        readonly completeRetirement: "retired";
+    };
+    readonly retired: {
+        readonly revive: "deploying";
+    };
+    readonly failed: {
+        readonly retry: "deploying";
+    };
+}, "deploying">;
+export type DeploymentLifecycle = StateOf<typeof deploymentLifecycle>;
+export type DeploymentLifecycleEvent = EventOf<typeof deploymentLifecycle>;

package/dist/schema/modules/deployment/states/deployment-lifecycle.js

@@ -0,0 +1,17 @@
+import { stateMachine } from '@astrale-os/sdk/state';
+/**
+ * Lifecycle of one immutable deployment. A deployment never changes code: it is created
+ * `deploying`, becomes `active` once its script serves, and leaves only by retirement. A failed
+ * creation can be retried on the same label; an expired retirement can be revived for the same
+ * owner and artifact.
+ */
+export const deploymentLifecycle = stateMachine({
+    initial: 'deploying',
+    transitions: {
+        deploying: { activate: 'active', fail: 'failed' },
+        active: { retire: 'retiring' },
+        retiring: { completeRetirement: 'retired' },
+        retired: { revive: 'deploying' },
+        failed: { retry: 'deploying' },
+    },
+});

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

@@ -0,0 +1,2 @@
+export { deploymentLifecycle } from './deployment-lifecycle.js';
+export type { DeploymentLifecycle, DeploymentLifecycleEvent } from './deployment-lifecycle.js';

package/dist/schema/modules/deployment/states/index.js

@@ -0,0 +1 @@
+export { deploymentLifecycle } from './deployment-lifecycle.js';

package/dist/schema/modules/deployment/types/deployment-record.d.ts

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+/** The commit a deployment was built from, as its deployer declared it. */
+export declare const deploymentCommit: z.ZodObject<{
+    sha: z.ZodString;
+    dirty: z.ZodBoolean;
+    base: z.ZodOptional<z.ZodObject<{
+        version: z.ZodString;
+        distance: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/**
+ * The `DeploymentRecordV1` one deploy declares, stored as declared beside the facts Services
+ * knows itself. Services admits it with the SDK's `acceptDeploymentRecord` before storing it, so
+ * this shape only bounds what the graph holds; any extension is a new record version.
+ */
+export declare const deploymentRecord: z.ZodObject<{
+    format: z.ZodLiteral<"astrale.deployment-record">;
+    version: z.ZodLiteral<1>;
+    origin: z.ZodString;
+    environment: z.ZodString;
+    releaseDigest: z.ZodString;
+    buildDigest: z.ZodString;
+    schemaRevision: z.ZodString;
+    configuration: z.ZodString;
+    providerScript: z.ZodString;
+    commit: z.ZodNullable<z.ZodObject<{
+        sha: z.ZodString;
+        dirty: z.ZodBoolean;
+        base: z.ZodOptional<z.ZodObject<{
+            version: z.ZodString;
+            distance: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type DeploymentRecord = z.output<typeof deploymentRecord>;

package/dist/schema/modules/deployment/types/deployment-record.js

@@ -0,0 +1,31 @@
+import { fullMatch } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+const digest = z.string().check(fullMatch('sha256:[0-9a-f]{64}'));
+/** The commit a deployment was built from, as its deployer declared it. */
+export const deploymentCommit = z.strictObject({
+    sha: z.string().check(fullMatch('[0-9a-fA-F]{40}')),
+    dirty: z.boolean(),
+    base: z
+        .strictObject({
+        version: z.string().min(1).max(256),
+        distance: z.number().int().min(0),
+    })
+        .optional(),
+});
+/**
+ * The `DeploymentRecordV1` one deploy declares, stored as declared beside the facts Services
+ * knows itself. Services admits it with the SDK's `acceptDeploymentRecord` before storing it, so
+ * this shape only bounds what the graph holds; any extension is a new record version.
+ */
+export const deploymentRecord = z.strictObject({
+    format: z.literal('astrale.deployment-record'),
+    version: z.literal(1),
+    origin: z.string().min(1).max(253),
+    environment: z.string().min(1).max(63),
+    releaseDigest: digest,
+    buildDigest: digest,
+    schemaRevision: digest,
+    configuration: digest,
+    providerScript: z.string().min(1).max(57),
+    commit: deploymentCommit.nullable(),
+});

package/dist/schema/modules/deployment/types/deployment-retention.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+/** A preview expires after 30 days without a call; a published deployment is retained. */
+export declare const deploymentRetention: z.ZodEnum<{
+    preview: "preview";
+    published: "published";
+}>;
+/** Why a deployment left: an expired preview can be revived, a withdrawn one never. */
+export declare const deploymentRetirement: z.ZodEnum<{
+    expired: "expired";
+    withdrawn: "withdrawn";
+}>;
+export type DeploymentRetention = z.output<typeof deploymentRetention>;
+export type DeploymentRetirement = z.output<typeof deploymentRetirement>;

package/dist/schema/modules/deployment/types/deployment-retention.js

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+/** A preview expires after 30 days without a call; a published deployment is retained. */
+export const deploymentRetention = z.enum(['preview', 'published']);
+/** Why a deployment left: an expired preview can be revived, a withdrawn one never. */
+export const deploymentRetirement = z.enum(['expired', 'withdrawn']);

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

@@ -0,0 +1,4 @@
+export { deploymentCommit, deploymentRecord } from './deployment-record.js';
+export type { DeploymentRecord } from './deployment-record.js';
+export { deploymentRetention, deploymentRetirement } from './deployment-retention.js';
+export type { DeploymentRetention, DeploymentRetirement } from './deployment-retention.js';

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

@@ -0,0 +1,2 @@
+export { deploymentCommit, deploymentRecord } from './deployment-record.js';
+export { deploymentRetention, deploymentRetirement } from './deployment-retention.js';