@norskvideo/norsk-auto-manager 0.1.0

package/lib/src/clock.d.ts

@@ -0,0 +1,14 @@
+export interface CancellableTimer {
+    cancel(): void;
+}
+export interface Clock {
+    now(): Date;
+    setTimeout(fn: () => void, ms: number): CancellableTimer;
+    setInterval(fn: () => void, ms: number): CancellableTimer;
+}
+export declare class RealClock implements Clock {
+    now(): Date;
+    setTimeout(fn: () => void, ms: number): CancellableTimer;
+    setInterval(fn: () => void, ms: number): CancellableTimer;
+}
+//# sourceMappingURL=clock.d.ts.map

package/lib/src/clock.js

@@ -0,0 +1,21 @@
+"use strict";
+// Clock abstraction so AutoManager can be tested deterministically.
+// Production code uses RealClock; tests inject a MockClock that exposes
+// advanceTime() to drive timers manually.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RealClock = void 0;
+class RealClock {
+    now() {
+        return new Date();
+    }
+    setTimeout(fn, ms) {
+        const handle = setTimeout(fn, ms);
+        return { cancel: () => clearTimeout(handle) };
+    }
+    setInterval(fn, ms) {
+        const handle = setInterval(fn, ms);
+        return { cancel: () => clearInterval(handle) };
+    }
+}
+exports.RealClock = RealClock;
+//# sourceMappingURL=clock.js.map

package/lib/src/conversions.d.ts

@@ -0,0 +1,59 @@
+import * as ManagerPB from "@norskvideo/norsk-api/lib/manager_pb";
+import * as CommonPB from "@norskvideo/norsk-api/lib/shared/common_pb";
+import { Bundle, BundleJobSpec, BundleState, Capability, CapabilityRequirement, GpuResource, IntraReplicaRules, JobRequirements, LaunchSpec, NodeAssignedJob, NodeInventory, PriorityBand, ResiliencePolicy } from "./types";
+export declare function fromPbPriorityBand(pb: ManagerPB.PriorityBand): PriorityBand;
+export declare function fromPbPlacementRule(pb: ManagerPB.PlacementRule): "off" | "soft" | "hard";
+export declare function fromPbCapability(pb: CommonPB.Capability): Capability;
+export declare function fromPbCapabilityRequirement(pb: CommonPB.CapabilityRequirement): CapabilityRequirement;
+export declare function fromPbGpuResource(pb: CommonPB.GpuResource): GpuResource;
+export declare function fromPbJobRequirements(pb: ManagerPB.JobRequirements): JobRequirements;
+export declare function fromPbBundle(pb: ManagerPB.Bundle): Bundle;
+export declare function fromPbBundleState(pb: ManagerPB.BundleState): BundleState;
+export declare function toPbBundleState(s: BundleState): ManagerPB.BundleState;
+export declare function fromPbBundleJobSpec(pb: ManagerPB.BundleJobSpec): BundleJobSpec;
+/**
+ * Reconstruct the typed `LaunchSpec` from the wire-form `Job` carried
+ * on a `BundleJobSpec`. If the carried Job has `productTemplate` set, this
+ * is a product-template launch; otherwise it's the legacy services/volumes
+ * path. The legacy variant passes the Job through as-is (cast to the
+ * SDK's typed shape — same trick the v0 code used).
+ */
+/** Tags starting with this prefix are SDK-managed (well-known reserved
+ *  names) — `__stopDateTime` carries the auto-stop instant for example.
+ *  Callers can't set them via `LaunchSpec.tags` (silently stripped on
+ *  outbound) and they're surfaced as typed fields rather than raw tags
+ *  on inbound. */
+export declare const RESERVED_TAG_PREFIX = "__";
+/** Well-known reserved tag carrying the operator's submitted auto-stop
+ *  instant. The daemon has no first-class concept of stop time, so we
+ *  ride along on its tag-preservation behaviour. */
+export declare const STOP_DATE_TIME_TAG = "__stopDateTime";
+export declare function fromPbLaunchSpec(pbJob: ManagerPB.Job): LaunchSpec;
+export declare function fromPbIntraReplicaRules(pb: ManagerPB.IntraReplicaRules): IntraReplicaRules;
+export declare function fromPbResiliencePolicy(pb: ManagerPB.ResiliencePolicy): ResiliencePolicy;
+export declare function fromPbNodeInventory(pb: CommonPB.NodeInventory): NodeInventory;
+export declare function fromPbNodeAssignedJob(pb: CommonPB.NodeAssignedJob): NodeAssignedJob;
+import { PlacementRule, PriorityBand as PbPriorityBand } from "@norskvideo/norsk-api/lib/manager_pb";
+export declare function toPbPriorityBand(b: PriorityBand): PbPriorityBand;
+export declare function toPbPlacementRule(r: "off" | "soft" | "hard"): PlacementRule;
+export declare function toPbCapability(c: Capability): CommonPB.Capability;
+export declare function toPbCapabilityRequirement(r: CapabilityRequirement): CommonPB.CapabilityRequirement;
+export declare function toPbJobRequirements(r: JobRequirements): ManagerPB.JobRequirements;
+export declare function toPbBundleJobSpec(j: BundleJobSpec): ManagerPB.BundleJobSpec;
+/**
+ * Project a typed `LaunchSpec` into the wire-form `Job` slot on
+ * `BundleJobSpec`. Manager stamps this template per replica during
+ * bundle expansion (setting jobId, tags, state, currentHash). For the
+ * product-template variant only `productTemplate`, `productTemplateParameters`, and
+ * `startDateTime` are meaningful — the rest stays at proto defaults.
+ * The worker reads `productTemplate` + `productTemplateParameters` and ignores
+ * services / volumes / writeFiles.
+ *
+ * `startDateTime` defaults to `new Date()` (immediate) when callers
+ * omit it; Manager-daemon's `apiToJobTemplate` rejects unset values.
+ */
+export declare function toPbLaunchSpec(launch: LaunchSpec): ManagerPB.Job;
+export declare function toPbIntraReplicaRules(r: IntraReplicaRules): ManagerPB.IntraReplicaRules;
+export declare function toPbResiliencePolicy(r: ResiliencePolicy): ManagerPB.ResiliencePolicy;
+export declare function toPbBundle(b: Bundle): ManagerPB.Bundle;
+//# sourceMappingURL=conversions.d.ts.map

package/lib/src/conversions.js

@@ -0,0 +1,416 @@
+"use strict";
+// PB ↔ AutoManager-typed conversions. The SDK passes raw protobuf
+// payloads through for the new AutoManager events; AutoManager runs
+// these converters at the boundary so the rest of the codebase works
+// against the cleaner typed shapes from `./types`.
+//
+// Converters are deliberately permissive about defaults: an empty map
+// from PB becomes `undefined` to match the optional-field convention
+// used in the typed model, an absent ID wrapper stays the empty string.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STOP_DATE_TIME_TAG = exports.RESERVED_TAG_PREFIX = void 0;
+exports.fromPbPriorityBand = fromPbPriorityBand;
+exports.fromPbPlacementRule = fromPbPlacementRule;
+exports.fromPbCapability = fromPbCapability;
+exports.fromPbCapabilityRequirement = fromPbCapabilityRequirement;
+exports.fromPbGpuResource = fromPbGpuResource;
+exports.fromPbJobRequirements = fromPbJobRequirements;
+exports.fromPbBundle = fromPbBundle;
+exports.fromPbBundleState = fromPbBundleState;
+exports.toPbBundleState = toPbBundleState;
+exports.fromPbBundleJobSpec = fromPbBundleJobSpec;
+exports.fromPbLaunchSpec = fromPbLaunchSpec;
+exports.fromPbIntraReplicaRules = fromPbIntraReplicaRules;
+exports.fromPbResiliencePolicy = fromPbResiliencePolicy;
+exports.fromPbNodeInventory = fromPbNodeInventory;
+exports.fromPbNodeAssignedJob = fromPbNodeAssignedJob;
+exports.toPbPriorityBand = toPbPriorityBand;
+exports.toPbPlacementRule = toPbPlacementRule;
+exports.toPbCapability = toPbCapability;
+exports.toPbCapabilityRequirement = toPbCapabilityRequirement;
+exports.toPbJobRequirements = toPbJobRequirements;
+exports.toPbBundleJobSpec = toPbBundleJobSpec;
+exports.toPbLaunchSpec = toPbLaunchSpec;
+exports.toPbIntraReplicaRules = toPbIntraReplicaRules;
+exports.toPbResiliencePolicy = toPbResiliencePolicy;
+exports.toPbBundle = toPbBundle;
+const protobuf_1 = require("@bufbuild/protobuf");
+const wkt_1 = require("@bufbuild/protobuf/wkt");
+const ManagerPB = __importStar(require("@norskvideo/norsk-api/lib/manager_pb"));
+const common_pb_1 = require("@norskvideo/norsk-api/lib/shared/common_pb");
+const norsk_manager_sdk_1 = require("@norskvideo/norsk-manager-sdk");
+const manager_pb_1 = require("@norskvideo/norsk-api/lib/manager_pb");
+// ----- enums -----------------------------------------------------------
+function fromPbPriorityBand(pb) {
+    switch (pb) {
+        case ManagerPB.PriorityBand.GOLD:
+            return "gold";
+        case ManagerPB.PriorityBand.SILVER:
+            return "silver";
+        case ManagerPB.PriorityBand.BRONZE:
+            return "bronze";
+    }
+}
+function fromPbPlacementRule(pb) {
+    switch (pb) {
+        case ManagerPB.PlacementRule.OFF:
+            return "off";
+        case ManagerPB.PlacementRule.SOFT:
+            return "soft";
+        case ManagerPB.PlacementRule.HARD:
+            return "hard";
+    }
+}
+// ----- capabilities ----------------------------------------------------
+function fromPbCapability(pb) {
+    return {
+        name: pb.name,
+        count: pb.count,
+        attributes: emptyMapToUndefined(pb.attributes),
+    };
+}
+function fromPbCapabilityRequirement(pb) {
+    return {
+        name: pb.name,
+        count: pb.count,
+        attributeMatches: emptyMapToUndefined(pb.attributeMatches),
+    };
+}
+// ----- GPU -------------------------------------------------------------
+function fromPbGpuResource(pb) {
+    return {
+        index: pb.index,
+        model: pb.model?.value,
+        totalCapacity: pb.totalCapacity,
+        reservedCapacity: pb.reservedCapacity,
+        exclusivelyReserved: pb.exclusivelyReserved,
+    };
+}
+// ----- requirements ----------------------------------------------------
+function fromPbJobRequirements(pb) {
+    return {
+        requiredCapacity: pb.requiredCapacity,
+        requiredCores: pb.requiredCores?.value,
+        requiredGpuCapacity: pb.requiredGpuCapacity?.value,
+        requiredGpuModel: pb.requiredGpuModel?.value,
+        requiredCapabilities: pb.requiredCapabilities.map(fromPbCapabilityRequirement),
+        priorityBand: fromPbPriorityBand(pb.priorityBand),
+    };
+}
+// ----- bundle ----------------------------------------------------------
+function fromPbBundle(pb) {
+    return {
+        bundleId: bundleIdString(pb.bundleId),
+        pool: pb.pool,
+        jobs: pb.jobs.map(fromPbBundleJobSpec),
+        intraReplicaPlacement: pb.intraReplicaPlacement
+            ? fromPbIntraReplicaRules(pb.intraReplicaPlacement)
+            : undefined,
+        resiliencePolicy: pb.resiliencePolicy ? fromPbResiliencePolicy(pb.resiliencePolicy) : undefined,
+        state: fromPbBundleState(pb.state),
+    };
+}
+function fromPbBundleState(pb) {
+    switch (pb) {
+        case ManagerPB.BundleState.DELETING:
+            return "deleting";
+        default:
+            return "live";
+    }
+}
+function toPbBundleState(s) {
+    switch (s) {
+        case "deleting":
+            return ManagerPB.BundleState.DELETING;
+        case "live":
+            return ManagerPB.BundleState.LIVE;
+    }
+}
+function fromPbBundleJobSpec(pb) {
+    return {
+        jobName: pb.jobName,
+        requirements: pb.requirements
+            ? fromPbJobRequirements(pb.requirements)
+            : {},
+        coLocateWith: emptyArrayToUndefined(pb.coLocateWith),
+        separateFrom: emptyArrayToUndefined(pb.separateFrom),
+        launch: pb.job ? fromPbLaunchSpec(pb.job) : undefined,
+    };
+}
+/**
+ * Reconstruct the typed `LaunchSpec` from the wire-form `Job` carried
+ * on a `BundleJobSpec`. If the carried Job has `productTemplate` set, this
+ * is a product-template launch; otherwise it's the legacy services/volumes
+ * path. The legacy variant passes the Job through as-is (cast to the
+ * SDK's typed shape — same trick the v0 code used).
+ */
+/** Tags starting with this prefix are SDK-managed (well-known reserved
+ *  names) — `__stopDateTime` carries the auto-stop instant for example.
+ *  Callers can't set them via `LaunchSpec.tags` (silently stripped on
+ *  outbound) and they're surfaced as typed fields rather than raw tags
+ *  on inbound. */
+exports.RESERVED_TAG_PREFIX = "__";
+/** Well-known reserved tag carrying the operator's submitted auto-stop
+ *  instant. The daemon has no first-class concept of stop time, so we
+ *  ride along on its tag-preservation behaviour. */
+exports.STOP_DATE_TIME_TAG = "__stopDateTime";
+function buildJobTags(stopDateTime, userTags) {
+    const out = {};
+    if (userTags) {
+        for (const [k, v] of Object.entries(userTags)) {
+            if (k.startsWith(exports.RESERVED_TAG_PREFIX))
+                continue; // silently strip
+            out[k] = v;
+        }
+    }
+    if (stopDateTime)
+        out[exports.STOP_DATE_TIME_TAG] = stopDateTime.toISOString();
+    return out;
+}
+function splitJobTags(tags) {
+    const userTags = {};
+    let stopDateTime;
+    for (const [k, v] of Object.entries(tags)) {
+        if (k === exports.STOP_DATE_TIME_TAG) {
+            const d = new Date(v);
+            if (!Number.isNaN(d.getTime()))
+                stopDateTime = d;
+            continue;
+        }
+        if (k.startsWith(exports.RESERVED_TAG_PREFIX))
+            continue; // unknown reserved — hide
+        userTags[k] = v;
+    }
+    return {
+        ...(stopDateTime ? { stopDateTime } : {}),
+        ...(Object.keys(userTags).length > 0 ? { userTags } : {}),
+    };
+}
+function fromPbLaunchSpec(pbJob) {
+    if (pbJob.productTemplate) {
+        const { stopDateTime, userTags } = splitJobTags(pbJob.tags ?? {});
+        return {
+            kind: "productTemplate",
+            ref: (0, norsk_manager_sdk_1.fromProductTemplateRef)(pbJob.productTemplate),
+            parameters: Object.keys(pbJob.productTemplateParameters).length > 0
+                ? pbJob.productTemplateParameters
+                : undefined,
+            // Preserve the operator's submitted schedule so consumers can
+            // surface it even before a JobPending event has been streamed
+            // (e.g. bundles in mgr's bundleMap whose materialised jobs
+            // haven't arrived yet — calendar view depends on this).
+            ...(pbJob.startDateTime ? { startDateTime: (0, wkt_1.timestampDate)(pbJob.startDateTime) } : {}),
+            ...(stopDateTime ? { stopDateTime } : {}),
+            ...(userTags ? { tags: userTags } : {}),
+        };
+    }
+    return { kind: "legacy", job: pbJob };
+}
+function fromPbIntraReplicaRules(pb) {
+    return {
+        sameNodeDefault: pb.sameNodeDefault,
+        sameAz: fromPbPlacementRule(pb.sameAz),
+    };
+}
+function fromPbResiliencePolicy(pb) {
+    return {
+        ...(pb.pool.length > 0 ? { pool: pb.pool } : {}),
+        sameNode: fromPbAntiAffinity(pb.sameNode),
+        sameAz: fromPbAntiAffinity(pb.sameAz),
+        sameCloud: fromPbAntiAffinity(pb.sameCloud),
+    };
+}
+function fromPbAntiAffinity(pb) {
+    return pb === ManagerPB.AntiAffinity.FORBID ? "forbid" : "allow";
+}
+function toPbAntiAffinity(a) {
+    return a === "forbid" ? ManagerPB.AntiAffinity.FORBID : ManagerPB.AntiAffinity.ALLOW;
+}
+// ----- inventory -------------------------------------------------------
+function fromPbNodeInventory(pb) {
+    return {
+        totalCapacity: pb.totalCapacity,
+        utilizationCap: pb.utilizationCap,
+        totalCores: pb.totalCores,
+        gpus: pb.gpus.map(fromPbGpuResource),
+        capabilities: pb.capabilities.map(fromPbCapability),
+        reservedCapacity: pb.reservedCapacity,
+        reservedCores: pb.reservedCores,
+        reservedCapabilities: pb.reservedCapabilities.map(fromPbCapability),
+        reachable: pb.reachable,
+        lastSeen: pb.lastSeen
+            ? new Date(Number(pb.lastSeen.seconds) * 1000 + (pb.lastSeen.nanos ?? 0) / 1000000)
+            : new Date(0),
+        cordoned: pb.cordoned,
+        assignedJobs: pb.assignedJobs.map(fromPbNodeAssignedJob),
+    };
+}
+function fromPbNodeAssignedJob(pb) {
+    return {
+        jobId: jobIdString(pb.jobId),
+        coreSet: pb.coreSet.length > 0 ? [...pb.coreSet] : undefined,
+        gpuIndex: pb.gpuIndex?.value,
+    };
+}
+// ----- helpers ---------------------------------------------------------
+function bundleIdString(pb) {
+    return pb?.bundleId ?? "";
+}
+function jobIdString(pb) {
+    return pb?.jobId ?? "";
+}
+function emptyMapToUndefined(m) {
+    return Object.keys(m).length > 0 ? { ...m } : undefined;
+}
+function emptyArrayToUndefined(arr) {
+    return arr.length > 0 ? [...arr] : undefined;
+}
+// =============================================================================
+// AutoManager-typed → PB conversions. Used when AutoManager submits a Bundle
+// (or future request types) over the wire.
+// =============================================================================
+const manager_pb_2 = require("@norskvideo/norsk-api/lib/manager_pb");
+const common_pb_2 = require("@norskvideo/norsk-api/lib/shared/common_pb");
+function toPbPriorityBand(b) {
+    switch (b) {
+        case "gold":
+            return manager_pb_2.PriorityBand.GOLD;
+        case "silver":
+            return manager_pb_2.PriorityBand.SILVER;
+        case "bronze":
+            return manager_pb_2.PriorityBand.BRONZE;
+    }
+}
+function toPbPlacementRule(r) {
+    switch (r) {
+        case "off":
+            return manager_pb_2.PlacementRule.OFF;
+        case "soft":
+            return manager_pb_2.PlacementRule.SOFT;
+        case "hard":
+            return manager_pb_2.PlacementRule.HARD;
+    }
+}
+function toPbCapability(c) {
+    return (0, protobuf_1.create)(common_pb_1.CapabilitySchema, {
+        name: c.name,
+        count: c.count,
+        attributes: c.attributes ?? {},
+    });
+}
+function toPbCapabilityRequirement(r) {
+    return (0, protobuf_1.create)(common_pb_1.CapabilityRequirementSchema, {
+        name: r.name,
+        count: r.count,
+        attributeMatches: r.attributeMatches ?? {},
+    });
+}
+function toPbJobRequirements(r) {
+    return (0, protobuf_1.create)(manager_pb_2.JobRequirementsSchema, {
+        requiredCapacity: r.requiredCapacity,
+        requiredCores: r.requiredCores !== undefined
+            ? (0, protobuf_1.create)(common_pb_1.OptionalIntSchema, { value: r.requiredCores })
+            : undefined,
+        requiredGpuCapacity: r.requiredGpuCapacity !== undefined
+            ? (0, protobuf_1.create)(common_pb_2.OptionalFloatSchema, { value: r.requiredGpuCapacity })
+            : undefined,
+        requiredGpuModel: r.requiredGpuModel !== undefined
+            ? (0, protobuf_1.create)(common_pb_1.OptionalStringSchema, { value: r.requiredGpuModel })
+            : undefined,
+        requiredCapabilities: r.requiredCapabilities.map(toPbCapabilityRequirement),
+        priorityBand: toPbPriorityBand(r.priorityBand),
+    });
+}
+function toPbBundleJobSpec(j) {
+    return (0, protobuf_1.create)(manager_pb_2.BundleJobSpecSchema, {
+        jobName: j.jobName,
+        requirements: toPbJobRequirements(j.requirements),
+        coLocateWith: j.coLocateWith ?? [],
+        separateFrom: j.separateFrom ?? [],
+        job: j.launch ? toPbLaunchSpec(j.launch) : undefined,
+    });
+}
+/**
+ * Project a typed `LaunchSpec` into the wire-form `Job` slot on
+ * `BundleJobSpec`. Manager stamps this template per replica during
+ * bundle expansion (setting jobId, tags, state, currentHash). For the
+ * product-template variant only `productTemplate`, `productTemplateParameters`, and
+ * `startDateTime` are meaningful — the rest stays at proto defaults.
+ * The worker reads `productTemplate` + `productTemplateParameters` and ignores
+ * services / volumes / writeFiles.
+ *
+ * `startDateTime` defaults to `new Date()` (immediate) when callers
+ * omit it; Manager-daemon's `apiToJobTemplate` rejects unset values.
+ */
+function toPbLaunchSpec(launch) {
+    if (launch.kind === "productTemplate") {
+        const tags = buildJobTags(launch.stopDateTime, launch.tags);
+        return (0, protobuf_1.create)(manager_pb_1.JobSchema, {
+            startDateTime: (0, wkt_1.timestampFromDate)(launch.startDateTime ?? new Date()),
+            productTemplate: (0, norsk_manager_sdk_1.toProductTemplateRef)(launch.ref),
+            productTemplateParameters: launch.parameters ?? {},
+            ...(Object.keys(tags).length > 0 ? { tags } : {}),
+        });
+    }
+    return launch.job;
+}
+function toPbIntraReplicaRules(r) {
+    return (0, protobuf_1.create)(manager_pb_2.IntraReplicaRulesSchema, {
+        sameNodeDefault: r.sameNodeDefault,
+        sameAz: toPbPlacementRule(r.sameAz),
+    });
+}
+function toPbResiliencePolicy(r) {
+    return (0, protobuf_1.create)(manager_pb_2.ResiliencePolicySchema, {
+        pool: r.pool ?? "",
+        sameNode: toPbAntiAffinity(r.sameNode),
+        sameAz: toPbAntiAffinity(r.sameAz),
+        sameCloud: toPbAntiAffinity(r.sameCloud),
+    });
+}
+function toPbBundle(b) {
+    return (0, protobuf_1.create)(manager_pb_2.BundleSchema, {
+        bundleId: (0, protobuf_1.create)(common_pb_1.BundleIdSchema, { bundleId: b.bundleId }),
+        pool: b.pool,
+        jobs: b.jobs.map(toPbBundleJobSpec),
+        intraReplicaPlacement: b.intraReplicaPlacement
+            ? toPbIntraReplicaRules(b.intraReplicaPlacement)
+            : undefined,
+        resiliencePolicy: b.resiliencePolicy ? toPbResiliencePolicy(b.resiliencePolicy) : undefined,
+        state: toPbBundleState(b.state ?? "live"),
+    });
+}
+//# sourceMappingURL=conversions.js.map

package/lib/src/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./automanager";
+export * from "./types";
+export { Clock, RealClock, CancellableTimer } from "./clock";
+export { KnownCapabilities, KnownCapabilityName } from "./knownCapabilities";
+export { validateBundle, ValidationError, ValidationErrorCode, ValidationResult, PoolDescriptor, NodeProfile, } from "./validation";
+export * from "./placement";
+export { freeCapability, freeCapacity, freeCores, findCapability, usedCapacityFraction, } from "./inventory";
+export { AutoSettingsValidationError, SettingsValidationError, SettingsValidationErrorCode, validateAutoSettings, } from "./settingsValidation";
+//# sourceMappingURL=index.d.ts.map

package/lib/src/index.js

@@ -0,0 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAutoSettings = exports.AutoSettingsValidationError = exports.usedCapacityFraction = exports.findCapability = exports.freeCores = exports.freeCapacity = exports.freeCapability = exports.validateBundle = exports.KnownCapabilities = exports.RealClock = void 0;
+// Public exports for @norskvideo/norsk-auto-manager.
+__exportStar(require("./automanager"), exports);
+__exportStar(require("./types"), exports);
+var clock_1 = require("./clock");
+Object.defineProperty(exports, "RealClock", { enumerable: true, get: function () { return clock_1.RealClock; } });
+var knownCapabilities_1 = require("./knownCapabilities");
+Object.defineProperty(exports, "KnownCapabilities", { enumerable: true, get: function () { return knownCapabilities_1.KnownCapabilities; } });
+var validation_1 = require("./validation");
+Object.defineProperty(exports, "validateBundle", { enumerable: true, get: function () { return validation_1.validateBundle; } });
+__exportStar(require("./placement"), exports);
+var inventory_1 = require("./inventory");
+Object.defineProperty(exports, "freeCapability", { enumerable: true, get: function () { return inventory_1.freeCapability; } });
+Object.defineProperty(exports, "freeCapacity", { enumerable: true, get: function () { return inventory_1.freeCapacity; } });
+Object.defineProperty(exports, "freeCores", { enumerable: true, get: function () { return inventory_1.freeCores; } });
+Object.defineProperty(exports, "findCapability", { enumerable: true, get: function () { return inventory_1.findCapability; } });
+Object.defineProperty(exports, "usedCapacityFraction", { enumerable: true, get: function () { return inventory_1.usedCapacityFraction; } });
+var settingsValidation_1 = require("./settingsValidation");
+Object.defineProperty(exports, "AutoSettingsValidationError", { enumerable: true, get: function () { return settingsValidation_1.AutoSettingsValidationError; } });
+Object.defineProperty(exports, "validateAutoSettings", { enumerable: true, get: function () { return settingsValidation_1.validateAutoSettings; } });
+//# sourceMappingURL=index.js.map

package/lib/src/inventory.d.ts

@@ -0,0 +1,34 @@
+import { Capability, NodeInventory } from "./types";
+/**
+ * Free capacity available for placement. `(totalCapacity * utilizationCap)
+ * - reservedCapacity`. Can be negative if the node is over-allocated;
+ * placement should treat negative values as "no room".
+ *
+ * @public
+ */
+export declare function freeCapacity(inv: NodeInventory): number;
+/** @public */
+export declare function freeCores(inv: NodeInventory): number;
+/**
+ * Fraction (0-1) of the node's total capacity currently reserved.
+ * Used by the bin-pack scoring strategy.
+ *
+ * @public
+ */
+export declare function usedCapacityFraction(inv: NodeInventory): number;
+/**
+ * Free count of a specific capability on this node. Looks up the total
+ * by name and subtracts whatever's currently reserved. Returns 0 if the
+ * capability isn't advertised.
+ *
+ * @public
+ */
+export declare function freeCapability(inv: NodeInventory, name: string): number;
+/**
+ * Find the advertised capability with the given name. Returns undefined
+ * if not present. Useful when callers also need attribute info.
+ *
+ * @public
+ */
+export declare function findCapability(inv: NodeInventory, name: string): Capability | undefined;
+//# sourceMappingURL=inventory.d.ts.map

package/lib/src/inventory.js

@@ -0,0 +1,64 @@
+"use strict";
+// Derivation helpers over NodeInventory snapshots. These are pure
+// projections — no state of their own — so the placement algorithm can
+// remain a pure function over what the worker advertised.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.freeCapacity = freeCapacity;
+exports.freeCores = freeCores;
+exports.usedCapacityFraction = usedCapacityFraction;
+exports.freeCapability = freeCapability;
+exports.findCapability = findCapability;
+/**
+ * Free capacity available for placement. `(totalCapacity * utilizationCap)
+ * - reservedCapacity`. Can be negative if the node is over-allocated;
+ * placement should treat negative values as "no room".
+ *
+ * @public
+ */
+function freeCapacity(inv) {
+    return inv.totalCapacity * inv.utilizationCap - inv.reservedCapacity;
+}
+/** @public */
+function freeCores(inv) {
+    return inv.totalCores - inv.reservedCores;
+}
+/**
+ * Fraction (0-1) of the node's total capacity currently reserved.
+ * Used by the bin-pack scoring strategy.
+ *
+ * @public
+ */
+function usedCapacityFraction(inv) {
+    if (inv.totalCapacity <= 0)
+        return 0;
+    return inv.reservedCapacity / inv.totalCapacity;
+}
+/**
+ * Free count of a specific capability on this node. Looks up the total
+ * by name and subtracts whatever's currently reserved. Returns 0 if the
+ * capability isn't advertised.
+ *
+ * @public
+ */
+function freeCapability(inv, name) {
+    const total = capabilityCount(inv.capabilities, name);
+    const used = capabilityCount(inv.reservedCapabilities, name);
+    return Math.max(0, total - used);
+}
+/**
+ * Find the advertised capability with the given name. Returns undefined
+ * if not present. Useful when callers also need attribute info.
+ *
+ * @public
+ */
+function findCapability(inv, name) {
+    return inv.capabilities.find((c) => c.name === name);
+}
+function capabilityCount(caps, name) {
+    let total = 0;
+    for (const c of caps)
+        if (c.name === name)
+            total += c.count;
+    return total;
+}
+//# sourceMappingURL=inventory.js.map

package/lib/src/knownCapabilities.d.ts

@@ -0,0 +1,18 @@
+/** @public */
+export declare const KnownCapabilities: {
+    /** Whole NVIDIA GPU, exclusive. For fractional, use requiredGpuCapacity. */
+    readonly NvidiaGpu: "norsk.io/nvidia-gpu";
+    /** Intel Quick Sync Video — fixed-function media accelerator. */
+    readonly IntelQsv: "norsk.io/intel-qsv";
+    /** Netint Quadra T1U accelerator. */
+    readonly Quadra: "norsk.io/quadra";
+    /** Blackmagic DeckLink capture/playout card. */
+    readonly Decklink: "norsk.io/decklink";
+    /** SMPTE ST 2110 capable NIC. */
+    readonly St2110Nic: "norsk.io/st2110-nic";
+    /** Media eXchange Layer slot, provided by an MXL bridge NodeService. */
+    readonly Mxl: "norsk.io/mxl";
+};
+/** @public */
+export type KnownCapabilityName = (typeof KnownCapabilities)[keyof typeof KnownCapabilities];
+//# sourceMappingURL=knownCapabilities.d.ts.map