@sequenceholdings/agent-spec 0.1.1 → 0.1.3

package/dist/voice-lifecycle-control.js

@@ -0,0 +1,138 @@
+import { z } from 'zod';
+import { voiceAgentScopeSchema, voiceIdSchema, voiceRevisionSchema, voiceScopeSchema, voiceTimestampSchema, } from './voice-common.js';
+import { voiceDependencyMaintenanceStateSchema } from './voice-lifecycle-states.js';
+export const voicePublicationPauseSchema = voiceAgentScopeSchema.extend({
+    publicationOperationId: voiceIdSchema,
+    status: z.enum(['ACTIVE', 'RELEASED']),
+    revision: voiceRevisionSchema,
+    claimedAt: voiceTimestampSchema,
+    releasedAt: voiceTimestampSchema.nullable(),
+}).superRefine((pause, context) => {
+    if (pause.status === 'ACTIVE' && pause.releasedAt !== null) {
+        context.addIssue({
+            code: 'custom', path: ['releasedAt'],
+            message: 'an active publication pause cannot have a release timestamp',
+        });
+    }
+    if (pause.status === 'RELEASED' && pause.releasedAt === null) {
+        context.addIssue({
+            code: 'custom', path: ['releasedAt'],
+            message: 'a released publication pause requires a release timestamp',
+        });
+    }
+    if (pause.releasedAt !== null && Date.parse(pause.releasedAt) < Date.parse(pause.claimedAt)) {
+        context.addIssue({
+            code: 'custom', path: ['releasedAt'],
+            message: 'a publication pause cannot be released before it was claimed',
+        });
+    }
+});
+export function claimVoicePublicationPause({ current, agentScope, publicationOperationId, claimedAt, }) {
+    const scope = voiceAgentScopeSchema.parse(agentScope);
+    const operationId = voiceIdSchema.parse(publicationOperationId);
+    const timestamp = voiceTimestampSchema.parse(claimedAt);
+    if (current === null) {
+        return { ok: true, changed: true, pause: makePause({
+                scope, operationId, revision: 0, claimedAt: timestamp,
+            }) };
+    }
+    const existing = voicePublicationPauseSchema.parse(current);
+    if (!sameAgentScope({ left: existing, right: scope })) {
+        return { ok: false, reason: 'SCOPE_MISMATCH' };
+    }
+    if (existing.publicationOperationId === operationId) {
+        return { ok: true, pause: existing, changed: false };
+    }
+    if (existing.status === 'ACTIVE') {
+        return { ok: false, reason: 'OWNED_BY_ANOTHER_OPERATION' };
+    }
+    return { ok: true, changed: true, pause: makePause({
+            scope, operationId, revision: existing.revision + 1, claimedAt: timestamp,
+        }) };
+}
+export function releaseVoicePublicationPause({ current, publicationOperationId, releasedAt, }) {
+    const existing = voicePublicationPauseSchema.parse(current);
+    const operationId = voiceIdSchema.parse(publicationOperationId);
+    const timestamp = voiceTimestampSchema.parse(releasedAt);
+    if (existing.publicationOperationId !== operationId) {
+        return { ok: false, reason: 'OWNED_BY_ANOTHER_OPERATION' };
+    }
+    if (existing.status === 'RELEASED') {
+        return { ok: true, pause: existing, changed: false };
+    }
+    return {
+        ok: true,
+        changed: true,
+        pause: voicePublicationPauseSchema.parse({
+            ...existing, status: 'RELEASED', revision: existing.revision + 1,
+            releasedAt: timestamp,
+        }),
+    };
+}
+export const voiceDependencyReferenceSchema = z.strictObject({
+    kind: z.literal('MANAGED_FUNCTION'),
+    managedFunctionId: voiceIdSchema,
+    observedVersionId: voiceIdSchema.nullable(),
+});
+export const voiceDependencyMaintenanceTargetSchema = z.discriminatedUnion('kind', [
+    z.strictObject({ kind: z.literal('ENVIRONMENT') }),
+    z.strictObject({
+        kind: z.literal('DEPENDENCIES'),
+        dependencies: z.array(voiceDependencyReferenceSchema).min(1),
+        affectedAgentIds: z.array(voiceIdSchema).min(1),
+    }),
+]);
+export const voiceDependencyMaintenanceFenceSchema = voiceScopeSchema.extend({
+    fenceId: voiceIdSchema,
+    target: voiceDependencyMaintenanceTargetSchema,
+    ownerPrincipalId: voiceIdSchema,
+    state: voiceDependencyMaintenanceStateSchema,
+    revision: voiceRevisionSchema,
+    createdAt: voiceTimestampSchema,
+    updatedAt: voiceTimestampSchema,
+});
+export const voiceAdmissionControlInputSchema = z.strictObject({
+    environmentEnabled: z.boolean(),
+    agentEnabled: z.boolean(),
+    routeEnabled: z.boolean(),
+    runtimeAccountEnabled: z.boolean(),
+    releaseReady: z.boolean(),
+    publicationPause: voicePublicationPauseSchema.nullable(),
+    dependencyMaintenanceBlocked: z.boolean(),
+});
+export const voiceAdmissionControlReasonSchema = z.enum([
+    'ENVIRONMENT_DISABLED', 'AGENT_DISABLED', 'ROUTE_DISABLED',
+    'RUNTIME_ACCOUNT_DISABLED', 'RELEASE_NOT_READY', 'PUBLICATION_PAUSED',
+    'DEPENDENCY_MAINTENANCE',
+]);
+export function evaluateVoiceAdmissionControl(input) {
+    const state = voiceAdmissionControlInputSchema.parse(input);
+    if (!state.environmentEnabled)
+        return { admitted: false, reason: 'ENVIRONMENT_DISABLED' };
+    if (!state.agentEnabled)
+        return { admitted: false, reason: 'AGENT_DISABLED' };
+    if (!state.routeEnabled)
+        return { admitted: false, reason: 'ROUTE_DISABLED' };
+    if (!state.runtimeAccountEnabled) {
+        return { admitted: false, reason: 'RUNTIME_ACCOUNT_DISABLED' };
+    }
+    if (!state.releaseReady)
+        return { admitted: false, reason: 'RELEASE_NOT_READY' };
+    if (state.publicationPause?.status === 'ACTIVE') {
+        return { admitted: false, reason: 'PUBLICATION_PAUSED' };
+    }
+    if (state.dependencyMaintenanceBlocked) {
+        return { admitted: false, reason: 'DEPENDENCY_MAINTENANCE' };
+    }
+    return { admitted: true };
+}
+function makePause({ scope, operationId, revision, claimedAt }) {
+    return voicePublicationPauseSchema.parse({
+        ...scope, publicationOperationId: operationId, status: 'ACTIVE', revision,
+        claimedAt, releasedAt: null,
+    });
+}
+function sameAgentScope({ left, right }) {
+    return left.tenantId === right.tenantId &&
+        left.environmentId === right.environmentId && left.agentId === right.agentId;
+}

package/dist/voice-lifecycle-session.d.ts

@@ -0,0 +1,168 @@
+import { z } from 'zod';
+import { type VoiceCallSubject } from './voice-authority.js';
+export declare const voiceReleaseLifecycleSchema: z.ZodObject<{
+    tenantId: z.ZodString;
+    environmentId: z.ZodString;
+    agentId: z.ZodString;
+    releaseId: z.ZodString;
+    publicationOperationId: z.ZodString;
+    state: z.ZodEnum<{
+        PREPARING: "PREPARING";
+        READY: "READY";
+        ACTIVE: "ACTIVE";
+        RETIRED: "RETIRED";
+        FAILED: "FAILED";
+        RECONCILIATION_REQUIRED: "RECONCILIATION_REQUIRED";
+    }>;
+    revision: z.ZodNumber;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type VoiceReleaseLifecycle = z.infer<typeof voiceReleaseLifecycleSchema>;
+export declare const voicePublicationOperationSchema: z.ZodObject<{
+    tenantId: z.ZodString;
+    environmentId: z.ZodString;
+    agentId: z.ZodString;
+    publicationOperationId: z.ZodString;
+    idempotencyKey: z.ZodString;
+    expectedDeploymentRevision: z.ZodNullable<z.ZodNumber>;
+    previousActiveReleaseId: z.ZodNullable<z.ZodString>;
+    candidateReleaseId: z.ZodNullable<z.ZodString>;
+    state: z.ZodEnum<{
+        PREPARING: "PREPARING";
+        FAILED: "FAILED";
+        RECONCILIATION_REQUIRED: "RECONCILIATION_REQUIRED";
+        WAITING_FOR_IDLE: "WAITING_FOR_IDLE";
+        ACTIVATING: "ACTIVATING";
+        SUCCEEDED: "SUCCEEDED";
+    }>;
+    revision: z.ZodNumber;
+    createdByPrincipalId: z.ZodString;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type VoicePublicationOperation = z.infer<typeof voicePublicationOperationSchema>;
+export declare const voiceCallerIdentitySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    direction: z.ZodLiteral<"INBOUND">;
+    initiatingStaffPrincipalId: z.ZodNull;
+    phoneCaller: z.ZodObject<{
+        classification: z.ZodLiteral<"UNAUTHENTICATED_PHONE_CALLER">;
+        callerId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    direction: z.ZodLiteral<"OUTBOUND">;
+    initiatingStaffPrincipalId: z.ZodString;
+    phoneCaller: z.ZodObject<{
+        classification: z.ZodLiteral<"REGISTERED_DESTINATION">;
+        destinationId: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>], "direction">;
+export type VoiceCallerIdentity = z.infer<typeof voiceCallerIdentitySchema>;
+export declare const voiceRuntimeBindingSchema: z.ZodObject<{
+    tenantId: z.ZodString;
+    environmentId: z.ZodString;
+    runtimeAccountId: z.ZodString;
+    observedRegistryUpdatedAt: z.ZodISODateTime;
+    checkedAt: z.ZodISODateTime;
+    accountStatus: z.ZodEnum<{
+        ACTIVE: "ACTIVE";
+        DISABLED: "DISABLED";
+    }>;
+    systemRunner: z.ZodLiteral<false>;
+}, z.core.$strict>;
+export type VoiceRuntimeBinding = z.infer<typeof voiceRuntimeBindingSchema>;
+export declare const voiceInboundRouteSchema: z.ZodObject<{
+    tenantId: z.ZodString;
+    environmentId: z.ZodString;
+    agentId: z.ZodString;
+    routeId: z.ZodString;
+    ownedPhoneNumberId: z.ZodString;
+    revision: z.ZodNumber;
+    enabled: z.ZodBoolean;
+    selectedByPrincipalId: z.ZodString;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type VoiceInboundRoute = z.infer<typeof voiceInboundRouteSchema>;
+export declare const voiceSessionLifecycleSchema: z.ZodObject<{
+    tenantId: z.ZodString;
+    environmentId: z.ZodString;
+    agentId: z.ZodString;
+    sessionId: z.ZodString;
+    releaseId: z.ZodString;
+    routeRevision: z.ZodNullable<z.ZodNumber>;
+    policyRevision: z.ZodNumber;
+    callerIdentity: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        direction: z.ZodLiteral<"INBOUND">;
+        initiatingStaffPrincipalId: z.ZodNull;
+        phoneCaller: z.ZodObject<{
+            classification: z.ZodLiteral<"UNAUTHENTICATED_PHONE_CALLER">;
+            callerId: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        direction: z.ZodLiteral<"OUTBOUND">;
+        initiatingStaffPrincipalId: z.ZodString;
+        phoneCaller: z.ZodObject<{
+            classification: z.ZodLiteral<"REGISTERED_DESTINATION">;
+            destinationId: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "direction">;
+    runtimeAccountId: z.ZodString;
+    systemRunner: z.ZodLiteral<false>;
+    state: z.ZodEnum<{
+        ACTIVE: "ACTIVE";
+        FAILED: "FAILED";
+        RESERVED: "RESERVED";
+        DISPATCHING: "DISPATCHING";
+        CONNECTING: "CONNECTING";
+        ENDING: "ENDING";
+        COMPLETED: "COMPLETED";
+        UNKNOWN: "UNKNOWN";
+        CANCELLING: "CANCELLING";
+        CANCELLED: "CANCELLED";
+    }>;
+    revision: z.ZodNumber;
+    admittedAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type VoiceSessionLifecycle = z.infer<typeof voiceSessionLifecycleSchema>;
+export declare const voiceRegistrationSubjectSchema: z.ZodObject<{
+    tenantId: z.ZodString;
+    environmentId: z.ZodString;
+    agentId: z.ZodString;
+    sessionId: z.ZodString;
+    releaseId: z.ZodString;
+}, z.core.$strict>;
+export type VoiceRegistrationSubject = VoiceCallSubject;
+export declare const voiceRegistrationOwnershipSchema: z.ZodObject<{
+    tenantId: z.ZodString;
+    environmentId: z.ZodString;
+    agentId: z.ZodString;
+    sessionId: z.ZodString;
+    releaseId: z.ZodString;
+    registrationOperationId: z.ZodString;
+    state: z.ZodEnum<{
+        FAILED: "FAILED";
+        RECONCILIATION_REQUIRED: "RECONCILIATION_REQUIRED";
+        SUCCEEDED: "SUCCEEDED";
+        CLAIMED: "CLAIMED";
+    }>;
+    revision: z.ZodNumber;
+    claimedAt: z.ZodISODateTime;
+    completedAt: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+export type VoiceRegistrationOwnership = z.infer<typeof voiceRegistrationOwnershipSchema>;
+type RegistrationClaimResult = {
+    ok: true;
+    registration: VoiceRegistrationOwnership;
+    changed: boolean;
+} | {
+    ok: false;
+    reason: 'OWNED_BY_ANOTHER_OPERATION' | 'SUBJECT_MISMATCH';
+};
+export declare function claimVoiceRegistration({ current, subject, registrationOperationId, claimedAt, }: {
+    current: VoiceRegistrationOwnership | null;
+    subject: VoiceRegistrationSubject;
+    registrationOperationId: string;
+    claimedAt: string;
+}): RegistrationClaimResult;
+export {};

package/dist/voice-lifecycle-session.js

@@ -0,0 +1,114 @@
+import { z } from 'zod';
+import { voiceCallSubjectSchema } from './voice-authority.js';
+import { voiceAgentScopeSchema, voiceIdSchema, voiceRevisionSchema, voiceScopeSchema, voiceTimestampSchema, } from './voice-common.js';
+import { voicePublicationStateSchema, voiceRegistrationStateSchema, voiceReleaseStateSchema, voiceSessionStateSchema, } from './voice-lifecycle-states.js';
+export const voiceReleaseLifecycleSchema = voiceAgentScopeSchema.extend({
+    releaseId: voiceIdSchema,
+    publicationOperationId: voiceIdSchema,
+    state: voiceReleaseStateSchema,
+    revision: voiceRevisionSchema,
+    createdAt: voiceTimestampSchema,
+    updatedAt: voiceTimestampSchema,
+});
+export const voicePublicationOperationSchema = voiceAgentScopeSchema.extend({
+    publicationOperationId: voiceIdSchema,
+    idempotencyKey: voiceIdSchema,
+    expectedDeploymentRevision: voiceRevisionSchema.nullable(),
+    previousActiveReleaseId: voiceIdSchema.nullable(),
+    candidateReleaseId: voiceIdSchema.nullable(),
+    state: voicePublicationStateSchema,
+    revision: voiceRevisionSchema,
+    createdByPrincipalId: voiceIdSchema,
+    createdAt: voiceTimestampSchema,
+    updatedAt: voiceTimestampSchema,
+});
+export const voiceCallerIdentitySchema = z.discriminatedUnion('direction', [
+    z.strictObject({
+        direction: z.literal('INBOUND'),
+        initiatingStaffPrincipalId: z.null(),
+        phoneCaller: z.strictObject({
+            classification: z.literal('UNAUTHENTICATED_PHONE_CALLER'),
+            callerId: z.string().trim().min(1).max(64).nullable(),
+        }),
+    }),
+    z.strictObject({
+        direction: z.literal('OUTBOUND'),
+        initiatingStaffPrincipalId: voiceIdSchema,
+        phoneCaller: z.strictObject({
+            classification: z.literal('REGISTERED_DESTINATION'),
+            destinationId: voiceIdSchema,
+        }),
+    }),
+]);
+export const voiceRuntimeBindingSchema = voiceScopeSchema.extend({
+    runtimeAccountId: voiceIdSchema,
+    observedRegistryUpdatedAt: voiceTimestampSchema,
+    checkedAt: voiceTimestampSchema,
+    accountStatus: z.enum(['ACTIVE', 'DISABLED']),
+    systemRunner: z.literal(false),
+});
+export const voiceInboundRouteSchema = voiceAgentScopeSchema.extend({
+    routeId: voiceIdSchema,
+    ownedPhoneNumberId: voiceIdSchema,
+    revision: voiceRevisionSchema,
+    enabled: z.boolean(),
+    selectedByPrincipalId: voiceIdSchema,
+    updatedAt: voiceTimestampSchema,
+});
+export const voiceSessionLifecycleSchema = voiceCallSubjectSchema.extend({
+    routeRevision: voiceRevisionSchema.nullable(),
+    policyRevision: voiceRevisionSchema,
+    callerIdentity: voiceCallerIdentitySchema,
+    runtimeAccountId: voiceIdSchema,
+    systemRunner: z.literal(false),
+    state: voiceSessionStateSchema,
+    revision: voiceRevisionSchema,
+    admittedAt: voiceTimestampSchema,
+    updatedAt: voiceTimestampSchema,
+});
+export const voiceRegistrationSubjectSchema = voiceCallSubjectSchema;
+export const voiceRegistrationOwnershipSchema = voiceRegistrationSubjectSchema.extend({
+    registrationOperationId: voiceIdSchema,
+    state: voiceRegistrationStateSchema,
+    revision: voiceRevisionSchema,
+    claimedAt: voiceTimestampSchema,
+    completedAt: voiceTimestampSchema.nullable(),
+});
+export function claimVoiceRegistration({ current, subject, registrationOperationId, claimedAt, }) {
+    const parsedSubject = voiceRegistrationSubjectSchema.parse({
+        tenantId: subject.tenantId,
+        environmentId: subject.environmentId,
+        agentId: subject.agentId,
+        sessionId: subject.sessionId,
+        releaseId: subject.releaseId,
+    });
+    const operationId = voiceIdSchema.parse(registrationOperationId);
+    const timestamp = voiceTimestampSchema.parse(claimedAt);
+    if (current !== null) {
+        const existing = voiceRegistrationOwnershipSchema.parse(current);
+        if (!sameSubject({ left: existing, right: parsedSubject })) {
+            return { ok: false, reason: 'SUBJECT_MISMATCH' };
+        }
+        if (existing.registrationOperationId !== operationId) {
+            return { ok: false, reason: 'OWNED_BY_ANOTHER_OPERATION' };
+        }
+        return { ok: true, registration: existing, changed: false };
+    }
+    return {
+        ok: true,
+        changed: true,
+        registration: voiceRegistrationOwnershipSchema.parse({
+            ...parsedSubject,
+            registrationOperationId: operationId,
+            state: 'CLAIMED',
+            revision: 0,
+            claimedAt: timestamp,
+            completedAt: null,
+        }),
+    };
+}
+function sameSubject({ left, right }) {
+    return left.tenantId === right.tenantId &&
+        left.environmentId === right.environmentId && left.agentId === right.agentId &&
+        left.sessionId === right.sessionId && left.releaseId === right.releaseId;
+}

package/dist/voice-lifecycle-states.d.ts

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+export declare const voiceCallDirectionSchema: z.ZodEnum<{
+    INBOUND: "INBOUND";
+    OUTBOUND: "OUTBOUND";
+}>;
+export type VoiceCallDirection = z.infer<typeof voiceCallDirectionSchema>;
+export declare const voiceReleaseStateSchema: z.ZodEnum<{
+    PREPARING: "PREPARING";
+    READY: "READY";
+    ACTIVE: "ACTIVE";
+    RETIRED: "RETIRED";
+    FAILED: "FAILED";
+    RECONCILIATION_REQUIRED: "RECONCILIATION_REQUIRED";
+}>;
+export type VoiceReleaseState = z.infer<typeof voiceReleaseStateSchema>;
+export declare const voicePublicationStateSchema: z.ZodEnum<{
+    PREPARING: "PREPARING";
+    FAILED: "FAILED";
+    RECONCILIATION_REQUIRED: "RECONCILIATION_REQUIRED";
+    WAITING_FOR_IDLE: "WAITING_FOR_IDLE";
+    ACTIVATING: "ACTIVATING";
+    SUCCEEDED: "SUCCEEDED";
+}>;
+export type VoicePublicationState = z.infer<typeof voicePublicationStateSchema>;
+export declare const voiceSessionStateSchema: z.ZodEnum<{
+    ACTIVE: "ACTIVE";
+    FAILED: "FAILED";
+    RESERVED: "RESERVED";
+    DISPATCHING: "DISPATCHING";
+    CONNECTING: "CONNECTING";
+    ENDING: "ENDING";
+    COMPLETED: "COMPLETED";
+    UNKNOWN: "UNKNOWN";
+    CANCELLING: "CANCELLING";
+    CANCELLED: "CANCELLED";
+}>;
+export type VoiceSessionState = z.infer<typeof voiceSessionStateSchema>;
+export declare const voiceRegistrationStateSchema: z.ZodEnum<{
+    FAILED: "FAILED";
+    RECONCILIATION_REQUIRED: "RECONCILIATION_REQUIRED";
+    SUCCEEDED: "SUCCEEDED";
+    CLAIMED: "CLAIMED";
+}>;
+export type VoiceRegistrationState = z.infer<typeof voiceRegistrationStateSchema>;
+export declare const voiceDependencyMaintenanceStateSchema: z.ZodEnum<{
+    RECONCILIATION_REQUIRED: "RECONCILIATION_REQUIRED";
+    DRAINING: "DRAINING";
+    MAINTENANCE: "MAINTENANCE";
+    VERIFYING: "VERIFYING";
+    REPUBLICATION_REQUIRED: "REPUBLICATION_REQUIRED";
+    RELEASED: "RELEASED";
+}>;
+export type VoiceDependencyMaintenanceState = z.infer<typeof voiceDependencyMaintenanceStateSchema>;
+type TransitionFailure = {
+    ok: false;
+    reason: 'TERMINAL_STATE' | 'RECONCILIATION_REQUIRED' | 'INVALID_TRANSITION';
+};
+type TransitionSuccess<TState> = {
+    ok: true;
+    state: TState;
+    changed: boolean;
+};
+export type VoiceReleaseTransition = TransitionSuccess<VoiceReleaseState> | TransitionFailure;
+export type VoicePublicationTransition = TransitionSuccess<VoicePublicationState> | TransitionFailure;
+export type VoiceSessionTransition = TransitionSuccess<VoiceSessionState> | TransitionFailure;
+export type VoiceRegistrationTransition = TransitionSuccess<VoiceRegistrationState> | TransitionFailure;
+export type VoiceDependencyMaintenanceTransition = TransitionSuccess<VoiceDependencyMaintenanceState> | TransitionFailure;
+export declare function transitionVoiceReleaseState({ from, to, reconciled }: {
+    from: VoiceReleaseState;
+    to: VoiceReleaseState;
+    reconciled?: boolean;
+}): VoiceReleaseTransition;
+export declare function transitionVoicePublicationState({ from, to, reconciled }: {
+    from: VoicePublicationState;
+    to: VoicePublicationState;
+    reconciled?: boolean;
+}): VoicePublicationTransition;
+export declare function transitionVoiceSessionState({ from, to, reconciled }: {
+    from: VoiceSessionState;
+    to: VoiceSessionState;
+    reconciled?: boolean;
+}): VoiceSessionTransition;
+export declare function transitionVoiceRegistrationState({ from, to, reconciled }: {
+    from: VoiceRegistrationState;
+    to: VoiceRegistrationState;
+    reconciled?: boolean;
+}): VoiceRegistrationTransition;
+export declare function transitionVoiceDependencyMaintenanceFence({ from, to, reconciled, }: {
+    from: VoiceDependencyMaintenanceState;
+    to: VoiceDependencyMaintenanceState;
+    reconciled?: boolean;
+}): VoiceDependencyMaintenanceTransition;
+export declare function isVoiceSessionReservationHeld({ state }: {
+    state: VoiceSessionState;
+}): boolean;
+export {};

package/dist/voice-lifecycle-states.js

@@ -0,0 +1,139 @@
+import { z } from 'zod';
+export const voiceCallDirectionSchema = z.enum(['INBOUND', 'OUTBOUND']);
+export const voiceReleaseStateSchema = z.enum([
+    'PREPARING', 'READY', 'ACTIVE', 'RETIRED', 'FAILED', 'RECONCILIATION_REQUIRED',
+]);
+export const voicePublicationStateSchema = z.enum([
+    'WAITING_FOR_IDLE', 'PREPARING', 'ACTIVATING', 'SUCCEEDED', 'FAILED',
+    'RECONCILIATION_REQUIRED',
+]);
+export const voiceSessionStateSchema = z.enum([
+    'RESERVED', 'DISPATCHING', 'CONNECTING', 'ACTIVE', 'ENDING', 'COMPLETED',
+    'FAILED', 'UNKNOWN', 'CANCELLING', 'CANCELLED',
+]);
+export const voiceRegistrationStateSchema = z.enum([
+    'CLAIMED', 'SUCCEEDED', 'FAILED', 'RECONCILIATION_REQUIRED',
+]);
+export const voiceDependencyMaintenanceStateSchema = z.enum([
+    'DRAINING', 'MAINTENANCE', 'VERIFYING', 'REPUBLICATION_REQUIRED', 'RELEASED',
+    'RECONCILIATION_REQUIRED',
+]);
+const releaseTransitions = {
+    PREPARING: ['READY', 'FAILED', 'RECONCILIATION_REQUIRED'],
+    READY: ['ACTIVE', 'FAILED', 'RECONCILIATION_REQUIRED'],
+    ACTIVE: ['RETIRED'],
+    RETIRED: [],
+    FAILED: [],
+    RECONCILIATION_REQUIRED: ['PREPARING', 'READY', 'FAILED'],
+};
+const publicationTransitions = {
+    WAITING_FOR_IDLE: ['PREPARING', 'FAILED', 'RECONCILIATION_REQUIRED'],
+    PREPARING: ['ACTIVATING', 'FAILED', 'RECONCILIATION_REQUIRED'],
+    ACTIVATING: ['SUCCEEDED', 'FAILED', 'RECONCILIATION_REQUIRED'],
+    SUCCEEDED: [],
+    FAILED: [],
+    RECONCILIATION_REQUIRED: [
+        'WAITING_FOR_IDLE', 'PREPARING', 'ACTIVATING', 'SUCCEEDED', 'FAILED',
+    ],
+};
+const sessionTransitions = {
+    RESERVED: ['DISPATCHING', 'CONNECTING', 'CANCELLING', 'FAILED', 'UNKNOWN'],
+    DISPATCHING: ['CONNECTING', 'CANCELLING', 'FAILED', 'UNKNOWN'],
+    CONNECTING: ['ACTIVE', 'CANCELLING', 'FAILED', 'UNKNOWN'],
+    ACTIVE: ['ENDING', 'CANCELLING', 'FAILED', 'UNKNOWN'],
+    ENDING: ['COMPLETED', 'CANCELLING', 'FAILED', 'UNKNOWN'],
+    COMPLETED: [],
+    FAILED: [],
+    UNKNOWN: [
+        'CONNECTING', 'ACTIVE', 'ENDING', 'COMPLETED', 'FAILED', 'CANCELLING',
+        'CANCELLED',
+    ],
+    CANCELLING: ['CANCELLED', 'COMPLETED', 'UNKNOWN'],
+    CANCELLED: [],
+};
+const registrationTransitions = {
+    CLAIMED: ['SUCCEEDED', 'FAILED', 'RECONCILIATION_REQUIRED'],
+    SUCCEEDED: [],
+    FAILED: [],
+    RECONCILIATION_REQUIRED: ['CLAIMED', 'SUCCEEDED', 'FAILED'],
+};
+const maintenanceTransitions = {
+    DRAINING: ['MAINTENANCE', 'RECONCILIATION_REQUIRED'],
+    MAINTENANCE: ['VERIFYING', 'RECONCILIATION_REQUIRED'],
+    VERIFYING: ['REPUBLICATION_REQUIRED', 'RECONCILIATION_REQUIRED'],
+    REPUBLICATION_REQUIRED: ['RELEASED', 'RECONCILIATION_REQUIRED'],
+    RELEASED: [],
+    RECONCILIATION_REQUIRED: [
+        'DRAINING', 'MAINTENANCE', 'VERIFYING', 'REPUBLICATION_REQUIRED', 'RELEASED',
+    ],
+};
+export function transitionVoiceReleaseState({ from, to, reconciled = false }) {
+    const result = transitionState({
+        from: voiceReleaseStateSchema.parse(from),
+        to: voiceReleaseStateSchema.parse(to),
+        reconciled,
+        transitions: releaseTransitions,
+        terminalStates: ['RETIRED', 'FAILED'],
+    });
+    return result.ok ? { ...result, state: voiceReleaseStateSchema.parse(result.state) } : result;
+}
+export function transitionVoicePublicationState({ from, to, reconciled = false }) {
+    const result = transitionState({
+        from: voicePublicationStateSchema.parse(from),
+        to: voicePublicationStateSchema.parse(to),
+        reconciled,
+        transitions: publicationTransitions,
+        terminalStates: ['SUCCEEDED', 'FAILED'],
+    });
+    return result.ok ? { ...result, state: voicePublicationStateSchema.parse(result.state) } : result;
+}
+export function transitionVoiceSessionState({ from, to, reconciled = false }) {
+    const result = transitionState({
+        from: voiceSessionStateSchema.parse(from),
+        to: voiceSessionStateSchema.parse(to),
+        reconciled,
+        transitions: sessionTransitions,
+        terminalStates: ['COMPLETED', 'FAILED', 'CANCELLED'],
+        reconciliationState: 'UNKNOWN',
+    });
+    return result.ok ? { ...result, state: voiceSessionStateSchema.parse(result.state) } : result;
+}
+export function transitionVoiceRegistrationState({ from, to, reconciled = false }) {
+    const result = transitionState({
+        from: voiceRegistrationStateSchema.parse(from),
+        to: voiceRegistrationStateSchema.parse(to),
+        reconciled,
+        transitions: registrationTransitions,
+        terminalStates: ['SUCCEEDED', 'FAILED'],
+    });
+    return result.ok ? { ...result, state: voiceRegistrationStateSchema.parse(result.state) } : result;
+}
+export function transitionVoiceDependencyMaintenanceFence({ from, to, reconciled = false, }) {
+    const result = transitionState({
+        from: voiceDependencyMaintenanceStateSchema.parse(from),
+        to: voiceDependencyMaintenanceStateSchema.parse(to),
+        reconciled,
+        transitions: maintenanceTransitions,
+        terminalStates: ['RELEASED'],
+    });
+    return result.ok
+        ? { ...result, state: voiceDependencyMaintenanceStateSchema.parse(result.state) }
+        : result;
+}
+export function isVoiceSessionReservationHeld({ state }) {
+    const current = voiceSessionStateSchema.parse(state);
+    return !['COMPLETED', 'FAILED', 'CANCELLED'].includes(current);
+}
+function transitionState({ from, to, reconciled, transitions, terminalStates, reconciliationState = 'RECONCILIATION_REQUIRED', }) {
+    if (from === to)
+        return { ok: true, state: to, changed: false };
+    if (terminalStates.includes(from))
+        return { ok: false, reason: 'TERMINAL_STATE' };
+    if (from === reconciliationState && !reconciled) {
+        return { ok: false, reason: 'RECONCILIATION_REQUIRED' };
+    }
+    if (!(transitions[from] ?? []).includes(to)) {
+        return { ok: false, reason: 'INVALID_TRANSITION' };
+    }
+    return { ok: true, state: to, changed: true };
+}

package/dist/voice-lifecycle.d.ts

@@ -0,0 +1,3 @@
+export * from './voice-lifecycle-control.js';
+export * from './voice-lifecycle-session.js';
+export * from './voice-lifecycle-states.js';

package/dist/voice-lifecycle.js

@@ -0,0 +1,3 @@
+export * from './voice-lifecycle-control.js';
+export * from './voice-lifecycle-session.js';
+export * from './voice-lifecycle-states.js';