@calltelemetry/ct-lab-mcp 0.8.69 → 0.8.71

package/dist/src/tools/legacy-guest-guard.js

@@ -0,0 +1,26 @@
+/** Legacy SDK effects have no canonical physical custody; flags cannot grant it. */
+export const LEGACY_GUEST_AUTHORITY_ERROR = "CANONICAL_PHYSICAL_SLOT_AUTHORITY_REQUIRED";
+const guestHandlers = new Set([
+    "appliance_exec", "factory_reset_appliance", "mount_iso", "unmount_iso", "create_snapshot",
+    "rollback_snapshot", "update_appliance_cli", "get_appliance_diagnostics", "manage_vm_network",
+    "get_guest_agent_status", "claim_cube", "release_cube", "provision_cube", "setup_cucm_emulator",
+    "clean_storage", "proxmox_quick_provision", "pin_pool_slots",
+]);
+const bridgedEffects = new Set([
+    "provision_vm", "auto_provision_vm", "claim_slot", "release_slot", "purge_slots", "purge_and_redeploy",
+    "cleanup_expired_vms", "prune_untracked_vms",
+]);
+export function legacyGuestHandlerBlocked(name, args, canonical) {
+    if (guestHandlers.has(name))
+        return true; // No qualified typed bridge for these legacy handlers.
+    if (canonical)
+        return false; // Existing typed CLI routes independently own admission.
+    if (bridgedEffects.has(name))
+        return true;
+    if (name === "vm_action")
+        return args?.action !== "status";
+    if (name === "find_slot")
+        return args?.autoClaim === true || args?.purgeIfFull === true;
+    return false;
+}
+//# sourceMappingURL=legacy-guest-guard.js.map

package/dist/src/tools/legacy-guest-guard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"legacy-guest-guard.js","sourceRoot":"","sources":["../../../src/tools/legacy-guest-guard.ts"],"names":[],"mappings":"AAAA,oFAAoF;AACpF,MAAM,CAAC,MAAM,4BAA4B,GAAG,4CAA4C,CAAC;AACzF,MAAM,aAAa,GAAG,IAAI,GAAG,CAAC;IAC5B,gBAAgB,EAAE,yBAAyB,EAAE,WAAW,EAAE,aAAa,EAAE,iBAAiB;IAC1F,mBAAmB,EAAE,sBAAsB,EAAE,2BAA2B,EAAE,mBAAmB;IAC7F,wBAAwB,EAAE,YAAY,EAAE,cAAc,EAAE,gBAAgB,EAAE,qBAAqB;IAC/F,eAAe,EAAE,yBAAyB,EAAE,gBAAgB;CAC7D,CAAC,CAAC;AACH,MAAM,cAAc,GAAG,IAAI,GAAG,CAAC;IAC7B,cAAc,EAAE,mBAAmB,EAAE,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,oBAAoB;IACtG,qBAAqB,EAAE,qBAAqB;CAC7C,CAAC,CAAC;AACH,MAAM,UAAU,yBAAyB,CAAC,IAAY,EAAE,IAAS,EAAE,SAAkB;IACnF,IAAI,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC,CAAC,uDAAuD;IACjG,IAAI,SAAS;QAAE,OAAO,KAAK,CAAC,CAAC,yDAAyD;IACtF,IAAI,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC;IAC1C,IAAI,IAAI,KAAK,WAAW;QAAE,OAAO,IAAI,EAAE,MAAM,KAAK,QAAQ,CAAC;IAC3D,IAAI,IAAI,KAAK,WAAW;QAAE,OAAO,IAAI,EAAE,SAAS,KAAK,IAAI,IAAI,IAAI,EAAE,WAAW,KAAK,IAAI,CAAC;IACxF,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/src/tools/license-tools.d.ts

@@ -62,10 +62,10 @@ export declare const ApplyLicenseInputSchema: z.ZodObject<{
     tier: "Demo" | "Community" | "Essentials" | "Advanced" | "Premium" | "Beta";
     port: number;
     targetPath: string;
+    mode: "auto" | "legacy" | "sideload";
     timeoutMs: number;
     orgId: number;
     days: number;
-    mode: "auto" | "legacy" | "sideload";
     token?: string | undefined;
     email?: string | undefined;
     host?: string | undefined;
@@ -90,12 +90,12 @@ export declare const ApplyLicenseInputSchema: z.ZodObject<{
     port?: number | undefined;
     purpose?: string | undefined;
     targetPath?: string | undefined;
+    mode?: "auto" | "legacy" | "sideload" | undefined;
     timeoutMs?: number | undefined;
     orgId?: number | undefined;
     days?: number | undefined;
     dashboardUrl?: string | undefined;
     dashboardApiKey?: string | undefined;
-    mode?: "auto" | "legacy" | "sideload" | undefined;
     applianceId?: string | undefined;
 }>;
 export type ApplyLicenseInput = z.infer<typeof ApplyLicenseInputSchema>;

package/dist/src/tools/physical-slot-claim-spec-schema.v1.json

@@ -0,0 +1 @@
+{"properties":{"adminEmail":{"default":"demo@calltelemetry.com","type":"string"},"adminPassword":{"type":"string"},"adminPasswordSecretRef":{"properties":{"key":{"default":"password","type":"string"},"name":{"type":"string"}},"type":"object"},"applianceId":{"type":"string"},"claimType":{"default":"dynamic","enum":["dynamic","fixture"],"type":"string"},"closed":{"type":"boolean"},"containerOverrides":{"properties":{"jtapi":{"type":"string"},"media":{"type":"string"},"syslog":{"type":"string"},"vue":{"type":"string"},"web":{"type":"string"}},"type":"object"},"cubes":{"items":{"properties":{"dialpeers":{"items":{"properties":{"codec":{"default":"g711ulaw","enum":["g711ulaw","g711alaw","g729","g729r8"],"type":"string"},"destinationPattern":{"type":"string"},"dtmfRelay":{"default":"rtp-nte","enum":["rtp-nte","cisco-rtp","sip-notify","sip-kpml"],"type":"string"},"incomingCalledNumber":{"type":"string"},"preference":{"default":0,"maximum":10,"minimum":0,"type":"integer"},"sessionTarget":{"type":"string"},"tag":{"maximum":2147483647,"minimum":1,"type":"integer"},"type":{"default":"voip","enum":["voip","pots"],"type":"string"}},"required":["tag"],"type":"object"},"type":"array"},"gatewayIp":{"pattern":"^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$","type":"string"},"ip":{"pattern":"^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$","type":"string"},"mode":{"default":"dynamic_vm","enum":["dynamic_vm","dynamic_mock","claim_fixture","in_guest_emulator"],"type":"string"},"name":{"type":"string"},"node":{"default":"proxmox","type":"string"},"role":{"enum":["cucm-edge","att-pstn","internal","external","standalone"],"type":"string"},"templateVmid":{"default":200,"type":"integer"},"vlan":{"default":125,"maximum":4094,"minimum":1,"type":"integer"},"vmid":{"maximum":299,"minimum":200,"type":"integer"},"xcc":{"properties":{"applianceUrl":{"type":"string"},"enabled":{"default":true,"type":"boolean"},"heartbeatIntervalSeconds":{"default":15,"maximum":300,"minimum":1,"type":"integer"},"remoteUrl":{"type":"string"}},"type":"object"}},"required":["name","role","mode","ip"],"type":"object"},"type":"array"},"cucmEmulator":{"properties":{"axlVersion":{"default":"14.0","enum":["11.5","12.0","12.5","14.0","15.0"],"type":"string"},"cdrPublisher":{"properties":{"enabled":{"default":true,"type":"boolean"},"intervalSeconds":{"default":60,"maximum":3600,"minimum":5,"type":"integer"},"sftpDestination":{"properties":{"host":{"type":"string"},"passwordSecretRef":{"properties":{"key":{"default":"password","type":"string"},"name":{"type":"string"}},"type":"object"},"path":{"default":"/var/spool/calltelemetry/cdr","type":"string"},"port":{"default":2222,"maximum":65535,"minimum":1,"type":"integer"},"username":{"default":"calltelemetry","type":"string"}},"type":"object"}},"type":"object"},"enabled":{"default":false,"type":"boolean"},"mockPhonesCount":{"default":10,"maximum":1000,"minimum":0,"type":"integer"},"mode":{"default":"dynamic_pod","enum":["dynamic_pod","in_guest","external"],"type":"string"},"profile":{"default":"standard-lab","type":"string"},"scenario":{"type":"string"}},"type":"object"},"enableCallManagers":{"default":true,"type":"boolean"},"enableCubes":{"default":true,"type":"boolean"},"licenseDays":{"default":90,"maximum":3650,"minimum":1,"type":"integer"},"licenseTier":{"default":"Demo","enum":["Demo","Community","Standard","Enterprise"],"type":"string"},"loadTesting":{"properties":{"calledNumberPattern":{"default":"+1555200XXXX","type":"string"},"callerIdPattern":{"default":"+1555100XXXX","type":"string"},"chaosErrorRate":{"default":0,"maximum":100,"minimum":0,"type":"number"},"codec":{"default":"g711ulaw","enum":["g711ulaw","g711alaw","g729"],"type":"string"},"concurrency":{"default":5,"maximum":500,"minimum":1,"type":"integer"},"cps":{"default":1,"maximum":500,"minimum":0.1,"type":"number"},"durationSeconds":{"default":60,"maximum":86400,"minimum":1,"type":"integer"},"enabled":{"default":false,"type":"boolean"},"target":{"default":"external_cube","enum":["external_cube","internal_cube","appliance"],"type":"string"}},"type":"object"},"mockPstn":{"properties":{"autoAnswer":{"default":true,"type":"boolean"},"callRateCps":{"default":2,"maximum":500,"minimum":0.1,"type":"number"},"destinationPrefix":{"default":"1...","type":"string"},"enabled":{"default":false,"type":"boolean"},"ip":{"pattern":"^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$","type":"string"},"sipPort":{"default":5060,"maximum":65535,"minimum":1,"type":"integer"},"vlan":{"default":123,"maximum":4094,"minimum":1,"type":"integer"}},"type":"object"},"node":{"default":"minis","type":"string"},"orgName":{"default":"CallTelemetry Demo","type":"string"},"paused":{"default":false,"type":"boolean"},"pausedReason":{"maxLength":500,"type":"string"},"phoneEmulator":{"properties":{"autoAnswer":{"default":true,"type":"boolean"},"bibAudioStreaming":{"default":true,"type":"boolean"},"bibStreaming":{"default":true,"type":"boolean"},"controlPlanePort":{"default":8080,"maximum":65535,"minimum":1024,"type":"integer"},"count":{"default":2,"maximum":500,"minimum":1,"type":"integer"},"cucmHost":{"type":"string"},"devicePrefix":{"default":"SEP","type":"string"},"enabled":{"default":false,"type":"boolean"},"mode":{"default":"dynamic_pod","enum":["dynamic_pod","in_guest"],"type":"string"},"model":{"default":"CP-7965G","type":"string"},"phoneCount":{"maximum":500,"minimum":1,"type":"integer"},"phoneWebXmlAccess":{"default":true,"type":"boolean"},"protocol":{"default":"SCCP","enum":["SCCP","SIP","sccp","sip"],"type":"string"},"webXmlAccess":{"default":true,"type":"boolean"}},"type":"object"},"preset":{"default":"comprehensive_demo","enum":["comprehensive_demo","standard_demo","minimal_demo","empty"],"type":"string"},"profile":{"default":"demo","enum":["demo","bare"],"type":"string"},"role":{"enum":["runner","gate","cucm","gateway","infra","harness"],"type":"string"},"sftp":{"properties":{"enabled":{"default":false,"type":"boolean"},"mode":{"default":"appliance_builtin","enum":["appliance_builtin","dynamic_pod"],"type":"string"},"passwordSecretRef":{"properties":{"key":{"default":"password","type":"string"},"name":{"type":"string"}},"type":"object"},"port":{"default":2222,"maximum":65535,"minimum":1,"type":"integer"},"stagingPath":{"default":"/opt/calltelemetry/cdr_staging","type":"string"},"user":{"default":"calltelemetry","type":"string"}},"type":"object"},"sideloadLicense":{"type":"string"},"sshUser":{"default":"calltelemetry","type":"string"},"state":{"enum":["Active","Closed"],"type":"string"},"targetIp":{"pattern":"^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$","type":"string"},"targetPort":{"default":2222,"maximum":65535,"minimum":1,"type":"integer"},"train":{"default":"stable","enum":["stable","beta","rc","candidate","dev","edge"],"type":"string"},"ttlHours":{"default":24,"maximum":8760,"minimum":0,"type":"integer"},"version":{"default":"0.8.6.27","type":"string"},"vmName":{"type":"string"},"vmid":{"maximum":8999,"minimum":100,"type":"integer"}},"type":"object"}

package/dist/src/tools/physical-slot.d.ts

@@ -0,0 +1,205 @@
+import { z } from "zod";
+import { type SlotApi } from "./slot-kubernetes.js";
+export declare const SLOT_ANNOTATION = "calltelemetry.com/physical-slot";
+export declare const SLOT_NONCE = "calltelemetry.com/physical-slot-operation-nonce";
+export declare const SLOT_REQUEST = "calltelemetry.com/physical-slot-request-sha256";
+declare const SlotSchema: z.ZodObject<{
+    hostAssetId: z.ZodString;
+    node: z.ZodString;
+    vmid: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    node: string;
+    vmid: number;
+    hostAssetId: string;
+}, {
+    node: string;
+    vmid: number;
+    hostAssetId: string;
+}>;
+export type PhysicalSlot = z.infer<typeof SlotSchema>;
+export declare const ReservationSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"physical-slot-reservation/v1">;
+    slot: z.ZodObject<{
+        hostAssetId: z.ZodString;
+        node: z.ZodString;
+        vmid: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        node: string;
+        vmid: number;
+        hostAssetId: string;
+    }, {
+        node: string;
+        vmid: number;
+        hostAssetId: string;
+    }>;
+    phase: z.ZodEnum<["provisional", "bound", "provider-bound", "retiring", "released"]>;
+    operationNonce: z.ZodEffects<z.ZodString, string, string>;
+    requestSha256: z.ZodString;
+    intendedClaim: z.ZodObject<{
+        namespace: z.ZodLiteral<"ct-lab">;
+        name: z.ZodEffects<z.ZodString, string, string>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        namespace: "ct-lab";
+    }, {
+        name: string;
+        namespace: "ct-lab";
+    }>;
+    context: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"mcp">;
+        issueKey: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        kind: "mcp";
+        issueKey?: string | undefined;
+    }, {
+        kind: "mcp";
+        issueKey?: string | undefined;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"operator">;
+        issueKey: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        kind: "operator";
+        issueKey?: string | undefined;
+    }, {
+        kind: "operator";
+        issueKey?: string | undefined;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"ct-meta">;
+        logicalAssetId: z.ZodString;
+        issueKey: z.ZodString;
+        importOperationId: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        kind: "ct-meta";
+        issueKey: string;
+        logicalAssetId: string;
+        importOperationId: string;
+    }, {
+        kind: "ct-meta";
+        issueKey: string;
+        logicalAssetId: string;
+        importOperationId: string;
+    }>]>;
+    claim: z.ZodNullable<z.ZodObject<{
+        namespace: z.ZodLiteral<"ct-lab">;
+        name: z.ZodEffects<z.ZodString, string, string>;
+        uid: z.ZodEffects<z.ZodString, string, string>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        namespace: "ct-lab";
+        uid: string;
+    }, {
+        name: string;
+        namespace: "ct-lab";
+        uid: string;
+    }>>;
+    provider: z.ZodNullable<z.ZodObject<{
+        uuid: z.ZodEffects<z.ZodString, string, string>;
+        vmName: z.ZodString;
+        managedOwnershipSha256: z.ZodString;
+        volumes: z.ZodArray<z.ZodString, "many">;
+    }, "strict", z.ZodTypeAny, {
+        uuid: string;
+        vmName: string;
+        managedOwnershipSha256: string;
+        volumes: string[];
+    }, {
+        uuid: string;
+        vmName: string;
+        managedOwnershipSha256: string;
+        volumes: string[];
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    claim: {
+        name: string;
+        namespace: "ct-lab";
+        uid: string;
+    } | null;
+    slot: {
+        node: string;
+        vmid: number;
+        hostAssetId: string;
+    };
+    schema: "physical-slot-reservation/v1";
+    phase: "released" | "provisional" | "bound" | "provider-bound" | "retiring";
+    operationNonce: string;
+    requestSha256: string;
+    intendedClaim: {
+        name: string;
+        namespace: "ct-lab";
+    };
+    context: {
+        kind: "mcp";
+        issueKey?: string | undefined;
+    } | {
+        kind: "operator";
+        issueKey?: string | undefined;
+    } | {
+        kind: "ct-meta";
+        issueKey: string;
+        logicalAssetId: string;
+        importOperationId: string;
+    };
+    provider: {
+        uuid: string;
+        vmName: string;
+        managedOwnershipSha256: string;
+        volumes: string[];
+    } | null;
+}, {
+    claim: {
+        name: string;
+        namespace: "ct-lab";
+        uid: string;
+    } | null;
+    slot: {
+        node: string;
+        vmid: number;
+        hostAssetId: string;
+    };
+    schema: "physical-slot-reservation/v1";
+    phase: "released" | "provisional" | "bound" | "provider-bound" | "retiring";
+    operationNonce: string;
+    requestSha256: string;
+    intendedClaim: {
+        name: string;
+        namespace: "ct-lab";
+    };
+    context: {
+        kind: "mcp";
+        issueKey?: string | undefined;
+    } | {
+        kind: "operator";
+        issueKey?: string | undefined;
+    } | {
+        kind: "ct-meta";
+        issueKey: string;
+        logicalAssetId: string;
+        importOperationId: string;
+    };
+    provider: {
+        uuid: string;
+        vmName: string;
+        managedOwnershipSha256: string;
+        volumes: string[];
+    } | null;
+}>;
+export type Reservation = z.infer<typeof ReservationSchema>;
+export declare function canonicalJson(value: any): string;
+export declare function physicalSlot(hostAssetId: string, node: string, vmid: number): PhysicalSlot;
+export declare function slotLeaseName(role: "mutex" | "reservation", slot: PhysicalSlot): string;
+export declare function creationOwnerSha(record: Reservation): string;
+export declare function claimPhysicalSlot(claim: any): PhysicalSlot;
+/** Internal dependency seam; callers cannot supply transport, clocks, nonce or permits. */
+export interface SlotDeps {
+    api: SlotApi;
+    now: () => number;
+    nonce: () => string;
+}
+export declare function createPhysicalClaim(manifest: any, deps?: SlotDeps): Promise<{
+    claim: any;
+    reservation: any;
+    reused: boolean;
+}>;
+export declare function deletePhysicalClaim(name: string, expectedUid: string, deps?: SlotDeps): Promise<any>;
+export {};
+//# sourceMappingURL=physical-slot.d.ts.map

package/dist/src/tools/physical-slot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"physical-slot.d.ts","sourceRoot":"","sources":["../../../src/tools/physical-slot.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAiB,KAAK,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAEnE,eAAO,MAAM,eAAe,oCAAoC,CAAC;AACjE,eAAO,MAAM,UAAU,oDAAoD,CAAC;AAC5E,eAAO,MAAM,YAAY,mDAAmD,CAAC;AAO7E,QAAA,MAAM,UAAU;;;;;;;;;;;;EAA2G,CAAC;AAC5H,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAOtD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOnB,CAAC;AACZ,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAK5D,wBAAgB,aAAa,CAAC,KAAK,EAAE,GAAG,GAAG,MAAM,CAIhD;AAED,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,YAAY,CAE1F;AACD,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,aAAa,EAAE,IAAI,EAAE,YAAY,GAAG,MAAM,CAIvF;AACD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAG5D;AACD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,GAAG,GAAG,YAAY,CAK1D;AAiDD,2FAA2F;AAC3F,MAAM,WAAW,QAAQ;IAAG,GAAG,EAAE,OAAO,CAAC;IAAC,GAAG,EAAE,MAAM,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,MAAM,CAAC;CAAE;AAyFnF,wBAAsB,mBAAmB,CAAC,QAAQ,EAAE,GAAG,EAAE,IAAI,WAAa,GAAG,OAAO,CAAC;IAAE,KAAK,EAAE,GAAG,CAAC;IAAC,WAAW,EAAE,GAAG,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,CAAC,CAmDtI;AACD,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,IAAI,WAAa,GAAG,OAAO,CAAC,GAAG,CAAC,CAsB5G"}

package/dist/src/tools/physical-slot.js

@@ -0,0 +1,295 @@
+/** Shared physical-slot authority (REL-1564). Durable records never expire or auto-clear. */
+import { createHash, randomUUID } from "node:crypto";
+import { z } from "zod";
+import { load as yamlLoad, JSON_SCHEMA } from "js-yaml";
+import { actualClaimIssue, claimCreationSha256, effectiveClaimSpec } from "./claim-creation-projection.js";
+import { createSlotApi } from "./slot-kubernetes.js";
+export const SLOT_ANNOTATION = "calltelemetry.com/physical-slot";
+export const SLOT_NONCE = "calltelemetry.com/physical-slot-operation-nonce";
+export const SLOT_REQUEST = "calltelemetry.com/physical-slot-request-sha256";
+const LEASES = "/apis/coordination.k8s.io/v1/namespaces/ct-lab/leases";
+const CLAIMS = "/apis/calltelemetry.com/v1alpha1/namespaces/ct-lab/applianceclaims";
+const printable = z.string().min(1).max(256).regex(/^[\x20-\x7e]+$/);
+const uuid = z.string().uuid().refine(value => value === value.toLowerCase(), "UUID must be canonical lowercase");
+const sha = z.string().regex(/^[0-9a-f]{64}$/);
+const objectName = z.string().min(1).max(253).refine(name => name.split(".").every(label => /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/.test(label)), "DNS subdomain labels must be nonempty and at most63 characters");
+const SlotSchema = z.object({ hostAssetId: printable, node: printable, vmid: z.number().safe().int().positive() }).strict();
+const ClaimIdentitySchema = z.object({ namespace: z.literal("ct-lab"), name: objectName, uid: uuid }).strict();
+const ContextSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("mcp"), issueKey: printable.optional() }).strict(),
+    z.object({ kind: z.literal("operator"), issueKey: printable.optional() }).strict(),
+    z.object({ kind: z.literal("ct-meta"), logicalAssetId: printable, issueKey: printable, importOperationId: printable }).strict(),
+]);
+export const ReservationSchema = z.object({
+    schema: z.literal("physical-slot-reservation/v1"), slot: SlotSchema,
+    phase: z.enum(["provisional", "bound", "provider-bound", "retiring", "released"]),
+    operationNonce: uuid, requestSha256: sha,
+    intendedClaim: z.object({ namespace: z.literal("ct-lab"), name: objectName }).strict(), context: ContextSchema,
+    claim: ClaimIdentitySchema.nullable(),
+    provider: z.object({ uuid, vmName: printable, managedOwnershipSha256: sha, volumes: z.array(z.string().min(1).max(512).regex(/^[\x20-\x7e]+$/)).max(256) }).strict().nullable(),
+}).strict();
+const MutexSchema = z.object({ schema: z.literal("physical-slot-mutex/v1"), slot: SlotSchema, ownerNonce: uuid, token: uuid }).strict();
+function requireSlot(ok, message) {
+    if (!ok)
+        throw new Error(`physical slot ${message}; retain reservation`);
+}
+export function canonicalJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(",")}]`;
+    if (value !== null && typeof value === "object")
+        return `{${Object.keys(value).sort().map(k => `${JSON.stringify(k)}:${canonicalJson(value[k])}`).join(",")}}`;
+    return JSON.stringify(value);
+}
+const digest = (value) => createHash("sha256").update(canonicalJson(value), "utf8").digest("hex");
+export function physicalSlot(hostAssetId, node, vmid) {
+    return SlotSchema.parse({ hostAssetId, node, vmid });
+}
+export function slotLeaseName(role, slot) {
+    SlotSchema.parse(slot);
+    const hash = digest([slot.hostAssetId, slot.node, slot.vmid]);
+    return `ct-physical-slot-${role}.${hash.slice(0, 32)}.${hash.slice(32)}`;
+}
+export function creationOwnerSha(record) {
+    const { schema, slot, operationNonce, requestSha256, intendedClaim, context } = ReservationSchema.parse(record);
+    return digest({ schema, slot, operationNonce, requestSha256, intendedClaim, context });
+}
+export function claimPhysicalSlot(claim) {
+    const node = claim?.spec?.node;
+    requireSlot(node === "minis" || node === "proxmox", "requires a canonical Proxmox node");
+    requireSlot(Number.isSafeInteger(claim.spec.vmid) && claim.spec.vmid >= 100 && claim.spec.vmid <= 8999, "requires an explicit provider VMID");
+    return physicalSlot(node === "minis" ? "proxmox-minis-lab" : "proxmox-lab", node, claim.spec.vmid);
+}
+function leaseEnvelope(lease, name) {
+    requireSlot(lease?.apiVersion === "coordination.k8s.io/v1" && lease.kind === "Lease"
+        && lease.metadata?.namespace === "ct-lab" && lease.metadata.name === name
+        && uuid.safeParse(lease.metadata.uid).success && typeof lease.metadata.resourceVersion === "string"
+        && lease.metadata.resourceVersion.length > 0 && !lease.metadata.deletionTimestamp, "Lease identity or CAS version differs");
+}
+function annotationJson(text) {
+    requireSlot(typeof text === "string" && Buffer.byteLength(text) <= 65_536, "annotation JSON unavailable or oversized");
+    const value = JSON.parse(text); // Accept only JSON syntax, not YAML extensions.
+    yamlLoad(text, { schema: JSON_SCHEMA, json: false }); // Reject duplicate/escaped duplicate keys.
+    return value;
+}
+function reservation(lease, slot) {
+    leaseEnvelope(lease, slotLeaseName("reservation", slot));
+    const record = ReservationSchema.parse(annotationJson(lease.metadata.annotations?.[SLOT_ANNOTATION]));
+    requireSlot(canonicalJson(record.slot) === canonicalJson(slot), "stored full tuple differs");
+    requireSlot(lease.spec && Object.keys(lease.spec).length === 0, "durable reservation has expiring lease semantics");
+    requireSlot(record.phase === "provisional" ? record.claim === null && record.provider === null : record.claim !== null, "phase and claim binding differ");
+    if (record.claim)
+        requireSlot(record.claim.namespace === record.intendedClaim.namespace && record.claim.name === record.intendedClaim.name, "bound claim differs from original intent");
+    if (record.provider)
+        requireSlot(canonicalJson(record.provider.volumes) === canonicalJson([...new Set(record.provider.volumes)].sort()), "provider volumes are not sorted and unique");
+    requireSlot(record.phase !== "provider-bound" || record.provider !== null, "provider phase lacks immutable provider binding");
+    return record;
+}
+function verifyClaim(live, record, expectedUid) {
+    requireSlot(live?.apiVersion === "calltelemetry.com/v1alpha1" && live.kind === "ApplianceClaim"
+        && live.metadata?.namespace === record.intendedClaim.namespace && live.metadata.name === record.intendedClaim.name
+        && uuid.safeParse(live.metadata.uid).success && (!expectedUid || live.metadata.uid === expectedUid)
+        && typeof live.metadata.resourceVersion === "string" && live.metadata.resourceVersion.length > 0
+        && canonicalJson(claimPhysicalSlot(live)) === canonicalJson(record.slot)
+        && live.metadata.annotations?.[SLOT_NONCE] === record.operationNonce
+        && live.metadata.annotations?.[SLOT_REQUEST] === record.requestSha256
+        && (actualClaimIssue(live) ?? null) === (record.context.issueKey ?? null)
+        && claimCreationSha256(live) === record.requestSha256, "independent claim UID, tuple or source lineage differs");
+}
+const MUTEX_FIELDS = ["holderIdentity", "leaseDurationSeconds", "acquireTime", "renewTime", "leaseTransitions"].sort();
+function wireTime(milliseconds) { return new Date(milliseconds).toISOString().replace(/Z$/, "000Z"); }
+function timeValue(value) {
+    requireSlot(typeof value === "string" && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{6}Z$/.test(value), "mutex timestamp is not canonical UTC microseconds");
+    const parsed = Date.parse(value);
+    requireSlot(Number.isFinite(parsed) && new Date(parsed).toISOString() === value.slice(0, 23) + "Z", "mutex timestamp is invalid");
+    return parsed;
+}
+function leaseBody(name, record, existing, spec = {}) {
+    return { apiVersion: "coordination.k8s.io/v1", kind: "Lease", metadata: {
+            ...(existing?.metadata || {}), name, namespace: "ct-lab",
+            annotations: { ...(existing?.metadata?.annotations || {}), [SLOT_ANNOTATION]: canonicalJson(record) },
+        }, spec };
+}
+const defaults = () => ({ api: createSlotApi(), now: Date.now, nonce: randomUUID });
+class Mutex {
+    deps;
+    slot;
+    lease;
+    owner;
+    timer;
+    tail = Promise.resolve();
+    failure;
+    constructor(deps, slot) {
+        this.deps = deps;
+        this.slot = slot;
+        this.owner = MutexSchema.parse({ schema: "physical-slot-mutex/v1", slot, ownerNonce: deps.nonce(), token: deps.nonce() });
+    }
+    name() { return slotLeaseName("mutex", this.slot); }
+    queue(fn) {
+        const run = this.tail.then(fn);
+        this.tail = run.catch(() => { });
+        return run;
+    }
+    validate(value) {
+        leaseEnvelope(value, this.name());
+        const wire = MutexSchema.parse(annotationJson(value.metadata.annotations?.[SLOT_ANNOTATION]));
+        requireSlot(canonicalJson(wire.slot) === canonicalJson(this.slot) && value.spec?.holderIdentity === wire.token
+            && value.spec.leaseDurationSeconds === 120 && Number.isSafeInteger(value.spec.leaseTransitions) && value.spec.leaseTransitions >= 0
+            && canonicalJson(Object.keys(value.spec).sort()) === canonicalJson(MUTEX_FIELDS)
+            && Number.isFinite(timeValue(value.spec.acquireTime)) && Number.isFinite(timeValue(value.spec.renewTime)), "mutex tuple, holder or duration differs");
+        return wire;
+    }
+    async enter() {
+        const path = `${LEASES}/${this.name()}`;
+        const previous = await this.deps.api.request(path, "GET");
+        if (previous) {
+            this.validate(previous);
+            requireSlot(Date.parse(previous.spec.renewTime) + 120_000 <= this.deps.now(), "mutex is occupied");
+        }
+        const transitions = previous ? previous.spec.leaseTransitions + 1 : 0;
+        requireSlot(Number.isSafeInteger(transitions), "mutex transition counter overflow");
+        const spec = { holderIdentity: this.owner.token, leaseDurationSeconds: 120, acquireTime: wireTime(this.deps.now()), renewTime: wireTime(this.deps.now()), leaseTransitions: transitions };
+        this.lease = await this.deps.api.request(previous ? path : LEASES, previous ? "PUT" : "POST", leaseBody(this.name(), this.owner, previous, spec));
+        this.validate(this.lease);
+        requireSlot(canonicalJson(this.validate(this.lease)) === canonicalJson(this.owner), "mutex creation returned another holder");
+        this.timer = setInterval(() => { void this.touch().catch(err => { this.failure = err; }); }, 20_000);
+        this.timer.unref();
+    }
+    async touch() {
+        return this.queue(async () => {
+            if (this.failure)
+                throw this.failure;
+            const path = `${LEASES}/${this.name()}`;
+            const live = await this.deps.api.request(path, "GET");
+            const wire = this.validate(live);
+            requireSlot(live.metadata.uid === this.lease.metadata.uid && canonicalJson(wire) === canonicalJson(this.owner)
+                && Date.parse(live.spec.renewTime) + 120_000 > this.deps.now(), "mutex ownership expired or changed");
+            this.lease = await this.deps.api.request(path, "PUT", leaseBody(this.name(), this.owner, live, { ...live.spec, renewTime: wireTime(this.deps.now()) }));
+            this.validate(this.lease);
+            requireSlot(this.lease.metadata.uid === live.metadata.uid && canonicalJson(this.validate(this.lease)) === canonicalJson(this.owner) && Date.parse(this.lease.spec.renewTime) + 120_000 > this.deps.now(), "mutex renewal did not preserve ownership");
+        });
+    }
+    async exit() {
+        if (this.timer)
+            clearInterval(this.timer);
+        await this.tail;
+        if (!this.lease || this.failure)
+            return;
+        try {
+            await this.queue(async () => {
+                const path = `${LEASES}/${this.name()}`;
+                const live = await this.deps.api.request(path, "GET");
+                requireSlot(live?.metadata?.uid === this.lease.metadata.uid && canonicalJson(this.validate(live)) === canonicalJson(this.owner), "mutex release owner differs");
+                await this.deps.api.request(path, "PUT", leaseBody(this.name(), this.owner, live, { ...live.spec, renewTime: "1970-01-01T00:00:00.000000Z" }));
+            });
+        }
+        catch { /* Unknown release never removes durable reservation; mutex expires naturally. */ }
+    }
+}
+async function withMutex(deps, slot, action) {
+    const mutex = new Mutex(deps, slot);
+    try {
+        await mutex.enter();
+        return await action(mutex);
+    }
+    finally {
+        await mutex.exit();
+    }
+}
+async function noOtherClaim(deps, slot, ownUid) {
+    let next = "";
+    for (let page = 0; page < 10; page++) {
+        const result = await deps.api.request(`${CLAIMS}?limit=500${next ? `&continue=${encodeURIComponent(next)}` : ""}`, "GET");
+        requireSlot(result?.kind === "ApplianceClaimList" && result.apiVersion === "calltelemetry.com/v1alpha1" && Array.isArray(result.items), "claim occupancy list unavailable");
+        for (const claim of result.items) {
+            if (claim.metadata?.uid === ownUid)
+                continue;
+            const id = claim.spec?.vmid;
+            const node = claim.spec?.node;
+            const alias = node === "proxmox-lab" ? "proxmox" : ["proxmox-mini", "proxmox-minis-lab"].includes(node) ? "minis" : node;
+            if (String(id) === String(slot.vmid) && (alias === slot.node || !["minis", "proxmox", "esxi"].includes(alias)))
+                throw new Error("physical slot has another existing ApplianceClaim; retain reservation");
+        }
+        next = result.metadata?.continue || "";
+        requireSlot(typeof next === "string", "claim occupancy pagination malformed");
+        if (!next)
+            return;
+    }
+    throw new Error("physical slot claim occupancy scan incomplete; retain reservation");
+}
+export async function createPhysicalClaim(manifest, deps = defaults()) {
+    requireSlot(manifest.metadata?.namespace === "ct-lab", "namespace must be ct-lab");
+    objectName.parse(manifest.metadata.name);
+    manifest = { ...manifest, spec: effectiveClaimSpec(manifest.spec) };
+    const slot = claimPhysicalSlot(manifest);
+    requireSlot(typeof manifest.spec.vmName === "string" && manifest.spec.vmName.length > 0, "constructor must provide the actual VM name before claim POST");
+    requireSlot(Number.isInteger(manifest.spec?.ttlHours) && manifest.spec.ttlHours > 0 && manifest.spec.ttlHours <= 8760, "dynamic claim requires finite TTL");
+    const context = ContextSchema.parse({ kind: "mcp", ...(actualClaimIssue(manifest) ? { issueKey: actualClaimIssue(manifest) } : {}) });
+    const requestSha256 = claimCreationSha256(manifest);
+    return withMutex(deps, slot, async (mutex) => {
+        const path = `${LEASES}/${slotLeaseName("reservation", slot)}`;
+        let existing = await deps.api.request(path, "GET");
+        if (existing) {
+            const held = reservation(existing, slot);
+            requireSlot(["bound", "provider-bound"].includes(held.phase) && held.requestSha256 === requestSha256
+                && canonicalJson(held.context) === canonicalJson(context) && held.intendedClaim.name === manifest.metadata.name, "durable reservation is occupied");
+            const live = await deps.api.request(`${CLAIMS}/${manifest.metadata.name}`, "GET");
+            verifyClaim(live, held, held.claim.uid);
+            requireSlot(!live.metadata.deletionTimestamp && live.spec?.closed !== true && live.spec?.state !== "Closed" && live.status?.phase !== "Closed", "bound claim is retiring");
+            requireSlot(Number.isInteger(live.spec?.ttlHours) && live.spec.ttlHours >= manifest.spec.ttlHours && live.spec.ttlHours <= 8760 && live.spec.claimType !== "fixture", "bound claim finite TTL differs");
+            if (live.status?.phase === "Ready" || live.status?.completionTime) {
+                const baseline = Date.parse(live.status?.completionTime || "");
+                requireSlot(Number.isFinite(baseline) && baseline + live.spec.ttlHours * 3_600_000 > deps.now(), "bound claim expired or Ready TTL baseline unavailable");
+            }
+            await noOtherClaim(deps, slot, live.metadata.uid);
+            await mutex.touch();
+            const current = await deps.api.request(path, "GET");
+            requireSlot(current?.metadata?.uid === existing.metadata.uid && canonicalJson(reservation(current, slot)) === canonicalJson(held), "bound reservation changed during retry");
+            return { claim: live, reservation: { uid: existing.metadata.uid, creationOwnerSha256: creationOwnerSha(held), record: held }, reused: true };
+        }
+        await noOtherClaim(deps, slot);
+        const record = ReservationSchema.parse({ schema: "physical-slot-reservation/v1", slot, phase: "provisional", operationNonce: deps.nonce(), requestSha256,
+            intendedClaim: { namespace: "ct-lab", name: manifest.metadata.name }, context, claim: null, provider: null });
+        await mutex.touch();
+        existing = await deps.api.request(LEASES, "POST", leaseBody(slotLeaseName("reservation", slot), record));
+        requireSlot(canonicalJson(reservation(existing, slot)) === canonicalJson(record), "reservation creation returned another owner");
+        const protectedManifest = { ...manifest, metadata: { ...manifest.metadata, annotations: { ...(manifest.metadata.annotations || {}), [SLOT_NONCE]: record.operationNonce, [SLOT_REQUEST]: requestSha256 } } };
+        await mutex.touch();
+        const response = await deps.api.request(CLAIMS, "POST", protectedManifest);
+        requireSlot(uuid.safeParse(response?.metadata?.uid).success, "claim creation response lacks actual UID");
+        const live = await deps.api.request(`${CLAIMS}/${manifest.metadata.name}`, "GET");
+        verifyClaim(live, record, response.metadata.uid);
+        requireSlot(!live.metadata.deletionTimestamp, "new claim is already deleting");
+        const bound = { ...record, phase: "bound", claim: { ...record.intendedClaim, uid: live.metadata.uid } };
+        await mutex.touch();
+        const current = await deps.api.request(path, "GET");
+        requireSlot(current?.metadata?.uid === existing.metadata.uid && canonicalJson(reservation(current, slot)) === canonicalJson(record), "provisional reservation changed before UID binding");
+        existing = await deps.api.request(path, "PUT", leaseBody(slotLeaseName("reservation", slot), bound, current));
+        requireSlot(existing?.metadata?.uid === current.metadata.uid && canonicalJson(reservation(existing, slot)) === canonicalJson(bound), "UID binding not independently confirmed");
+        return { claim: live, reservation: { uid: existing.metadata.uid, creationOwnerSha256: creationOwnerSha(bound), record: bound }, reused: false };
+    });
+}
+export async function deletePhysicalClaim(name, expectedUid, deps = defaults()) {
+    objectName.parse(name);
+    uuid.parse(expectedUid);
+    const live = await deps.api.request(`${CLAIMS}/${name}`, "GET");
+    requireSlot(live?.metadata?.uid === expectedUid, "original selected claim UID differs or is absent");
+    const slot = claimPhysicalSlot(live);
+    return withMutex(deps, slot, async (mutex) => {
+        const path = `${LEASES}/${slotLeaseName("reservation", slot)}`;
+        let lease = await deps.api.request(path, "GET");
+        const held = reservation(lease, slot);
+        requireSlot(["bound", "provider-bound", "retiring"].includes(held.phase) && held.claim?.uid === expectedUid && held.intendedClaim.name === name, "claim does not own the bound reservation");
+        let selected = await deps.api.request(`${CLAIMS}/${name}`, "GET");
+        verifyClaim(selected, held, expectedUid);
+        const retiring = { ...held, phase: "retiring" };
+        await mutex.touch();
+        lease = await deps.api.request(path, "PUT", leaseBody(slotLeaseName("reservation", slot), retiring, lease));
+        requireSlot(canonicalJson(reservation(lease, slot)) === canonicalJson(retiring), "retiring reservation write failed");
+        await mutex.touch();
+        selected = await deps.api.request(`${CLAIMS}/${name}`, "GET");
+        verifyClaim(selected, retiring, expectedUid);
+        await deps.api.request(`${CLAIMS}/${name}`, "DELETE", { apiVersion: "v1", kind: "DeleteOptions", preconditions: { uid: expectedUid, resourceVersion: selected.metadata.resourceVersion } });
+        return { requested: true, expectedUid, reservationRetained: true, phase: "retiring", next: "The governed operator/controller must prove original claim, provider and owned-volume absence before releasing physical-slot custody." };
+    });
+}
+//# sourceMappingURL=physical-slot.js.map