@marinoscar/platform-contract 0.0.0-stage → 0.1.0-next.4

package/dist/cjs/nodes/constants.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Upper bound on `expiresInDays`: ten years, which is "effectively never" with a clock attached.
+ *
+ * @stability experimental
+ */
+export declare const MAX_NODE_CREDENTIAL_DAYS = 3650;
+/**
+ * Ceiling on a node's declared `concurrency`, and therefore on how many rows
+ * one claim call can take.
+ *
+ * 64 is not a hardware estimate — it is the point past which "this node is
+ * mis-declared" is more likely than "this node really can run that many
+ * jobs at once". A real box that can genuinely run more registers as two
+ * nodes, which the fleet page can then see and drain independently.
+ *
+ * @stability experimental
+ */
+export declare const MAX_NODE_CONCURRENCY = 64;
+/**
+ * Cap on how many job types one node may declare.
+ *
+ * @stability experimental
+ */
+export declare const MAX_NODE_ELIGIBLE_TYPES = 100;
+/**
+ * Length ceiling of a node credential's display `name`.
+ *
+ * @stability experimental
+ */
+export declare const MAX_NODE_CREDENTIAL_NAME_LENGTH = 100;
+/**
+ * `AdminNode.status`: OPERATOR state, not liveness. `online` accepts claims,
+ * `draining` finishes what it holds, `offline` deregistered or was swept,
+ * `disabled` is administratively refused.
+ *
+ * @stability experimental
+ */
+export declare const NODE_STATUSES: readonly ["online", "draining", "offline", "disabled"];
+/**
+ * `AdminNode.health`: DERIVED liveness, computed at read time and never
+ * stored. Read alongside `status`, never instead of it.
+ *
+ * @stability experimental
+ */
+export declare const NODE_HEALTHS: readonly ["healthy", "stale", "offline"];
+/**
+ * The phase spans a node always relays, in the order a job runs them. The set
+ * is closed on purpose (a node cannot mint arbitrary span names in the trace
+ * store); an executor's own spans use the `job.app.<name>` shape instead
+ * ({@link NODE_APP_SPAN_NAME_PATTERN}).
+ *
+ * @stability experimental
+ */
+export declare const BUILTIN_NODE_SPAN_NAMES: readonly ["job.download", "job.execute", "job.upload", "job.submit", "job.secret"];
+/**
+ * What an executor's own span name must look like: `job.app.` and then a
+ * lower-case name of 2 to 48 characters. The fixed prefix is the point: an
+ * app span can never collide with a built-in phase or with another attribute
+ * namespace, and the trace store's span-name cardinality is bounded by the
+ * executors a deployment installs, not by what a node sends.
+ *
+ * @stability experimental
+ */
+export declare const NODE_APP_SPAN_NAME_PATTERN: RegExp;
+/**
+ * What an `extra` vital's key must look like: a lower-case letter, then 1 to
+ * 47 lower-case letters, digits, `_` or `.`.
+ *
+ * @stability experimental
+ */
+export declare const NODE_VITALS_EXTRA_KEY_PATTERN: RegExp;
+/**
+ * Most keys one heartbeat's `vitals.extra` may carry.
+ *
+ * @stability experimental
+ */
+export declare const MAX_NODE_VITALS_EXTRA_KEYS = 16;
+/**
+ * Largest magnitude of an `extra` vital. Generous (a quadrillion): the ceiling
+ * keeps a number that is too large to be true out of the row, it is not a
+ * statement about any real reading.
+ *
+ * @stability experimental
+ */
+export declare const MAX_NODE_VITALS_EXTRA_VALUE = 1000000000000000;
+//# sourceMappingURL=constants.d.ts.map

package/dist/cjs/nodes/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/nodes/constants.ts"],"names":[],"mappings":"AAQA;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,OAAO,CAAC;AAE7C;;;;;;;;;;GAUG;AACH,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAEvC;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAE3C;;;;GAIG;AACH,eAAO,MAAM,+BAA+B,MAAM,CAAC;AAEnD;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,wDAAyD,CAAC;AAEpF;;;;;GAKG;AACH,eAAO,MAAM,YAAY,0CAA2C,CAAC;AAErE;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB,oFAM1B,CAAC;AAEX;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B,QAAuC,CAAC;AAE/E;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,QAA4B,CAAC;AAEvE;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,KAAK,CAAC;AAE7C;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,mBAAO,CAAC"}

package/dist/cjs/nodes/constants.js

@@ -0,0 +1,102 @@
+"use strict";
+// =============================================================================
+// Nodes: plain values of the node routes' wire shapes (issue #734, PP-8.2)
+// =============================================================================
+//
+// Zod-free bounds of the node control plane and the node credential routes.
+// Moved from the API slice's dto files with their comments.
+// =============================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_NODE_VITALS_EXTRA_VALUE = exports.MAX_NODE_VITALS_EXTRA_KEYS = exports.NODE_VITALS_EXTRA_KEY_PATTERN = exports.NODE_APP_SPAN_NAME_PATTERN = exports.BUILTIN_NODE_SPAN_NAMES = exports.NODE_HEALTHS = exports.NODE_STATUSES = exports.MAX_NODE_CREDENTIAL_NAME_LENGTH = exports.MAX_NODE_ELIGIBLE_TYPES = exports.MAX_NODE_CONCURRENCY = exports.MAX_NODE_CREDENTIAL_DAYS = void 0;
+/**
+ * Upper bound on `expiresInDays`: ten years, which is "effectively never" with a clock attached.
+ *
+ * @stability experimental
+ */
+exports.MAX_NODE_CREDENTIAL_DAYS = 3650;
+/**
+ * Ceiling on a node's declared `concurrency`, and therefore on how many rows
+ * one claim call can take.
+ *
+ * 64 is not a hardware estimate — it is the point past which "this node is
+ * mis-declared" is more likely than "this node really can run that many
+ * jobs at once". A real box that can genuinely run more registers as two
+ * nodes, which the fleet page can then see and drain independently.
+ *
+ * @stability experimental
+ */
+exports.MAX_NODE_CONCURRENCY = 64;
+/**
+ * Cap on how many job types one node may declare.
+ *
+ * @stability experimental
+ */
+exports.MAX_NODE_ELIGIBLE_TYPES = 100;
+/**
+ * Length ceiling of a node credential's display `name`.
+ *
+ * @stability experimental
+ */
+exports.MAX_NODE_CREDENTIAL_NAME_LENGTH = 100;
+/**
+ * `AdminNode.status`: OPERATOR state, not liveness. `online` accepts claims,
+ * `draining` finishes what it holds, `offline` deregistered or was swept,
+ * `disabled` is administratively refused.
+ *
+ * @stability experimental
+ */
+exports.NODE_STATUSES = ['online', 'draining', 'offline', 'disabled'];
+/**
+ * `AdminNode.health`: DERIVED liveness, computed at read time and never
+ * stored. Read alongside `status`, never instead of it.
+ *
+ * @stability experimental
+ */
+exports.NODE_HEALTHS = ['healthy', 'stale', 'offline'];
+/**
+ * The phase spans a node always relays, in the order a job runs them. The set
+ * is closed on purpose (a node cannot mint arbitrary span names in the trace
+ * store); an executor's own spans use the `job.app.<name>` shape instead
+ * ({@link NODE_APP_SPAN_NAME_PATTERN}).
+ *
+ * @stability experimental
+ */
+exports.BUILTIN_NODE_SPAN_NAMES = [
+    'job.download',
+    'job.execute',
+    'job.upload',
+    'job.submit',
+    'job.secret',
+];
+/**
+ * What an executor's own span name must look like: `job.app.` and then a
+ * lower-case name of 2 to 48 characters. The fixed prefix is the point: an
+ * app span can never collide with a built-in phase or with another attribute
+ * namespace, and the trace store's span-name cardinality is bounded by the
+ * executors a deployment installs, not by what a node sends.
+ *
+ * @stability experimental
+ */
+exports.NODE_APP_SPAN_NAME_PATTERN = /^job\.app\.[a-z][a-z0-9_.-]{1,47}$/;
+/**
+ * What an `extra` vital's key must look like: a lower-case letter, then 1 to
+ * 47 lower-case letters, digits, `_` or `.`.
+ *
+ * @stability experimental
+ */
+exports.NODE_VITALS_EXTRA_KEY_PATTERN = /^[a-z][a-z0-9_.]{1,47}$/;
+/**
+ * Most keys one heartbeat's `vitals.extra` may carry.
+ *
+ * @stability experimental
+ */
+exports.MAX_NODE_VITALS_EXTRA_KEYS = 16;
+/**
+ * Largest magnitude of an `extra` vital. Generous (a quadrillion): the ceiling
+ * keeps a number that is too large to be true out of the row, it is not a
+ * statement about any real reading.
+ *
+ * @stability experimental
+ */
+exports.MAX_NODE_VITALS_EXTRA_VALUE = 1e15;
+//# sourceMappingURL=constants.js.map

package/dist/cjs/nodes/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../src/nodes/constants.ts"],"names":[],"mappings":";AAAA,gFAAgF;AAChF,2EAA2E;AAC3E,gFAAgF;AAChF,EAAE;AACF,4EAA4E;AAC5E,4DAA4D;AAC5D,gFAAgF;;;AAEhF;;;;GAIG;AACU,QAAA,wBAAwB,GAAG,IAAI,CAAC;AAE7C;;;;;;;;;;GAUG;AACU,QAAA,oBAAoB,GAAG,EAAE,CAAC;AAEvC;;;;GAIG;AACU,QAAA,uBAAuB,GAAG,GAAG,CAAC;AAE3C;;;;GAIG;AACU,QAAA,+BAA+B,GAAG,GAAG,CAAC;AAEnD;;;;;;GAMG;AACU,QAAA,aAAa,GAAG,CAAC,QAAQ,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,CAAU,CAAC;AAEpF;;;;;GAKG;AACU,QAAA,YAAY,GAAG,CAAC,SAAS,EAAE,OAAO,EAAE,SAAS,CAAU,CAAC;AAErE;;;;;;;GAOG;AACU,QAAA,uBAAuB,GAAG;IACrC,cAAc;IACd,aAAa;IACb,YAAY;IACZ,YAAY;IACZ,YAAY;CACJ,CAAC;AAEX;;;;;;;;GAQG;AACU,QAAA,0BAA0B,GAAG,oCAAoC,CAAC;AAE/E;;;;;GAKG;AACU,QAAA,6BAA6B,GAAG,yBAAyB,CAAC;AAEvE;;;;GAIG;AACU,QAAA,0BAA0B,GAAG,EAAE,CAAC;AAE7C;;;;;;GAMG;AACU,QAAA,2BAA2B,GAAG,IAAI,CAAC"}

package/dist/cjs/nodes/index.d.ts

@@ -0,0 +1,8 @@
+export { BUILTIN_NODE_SPAN_NAMES, MAX_NODE_CONCURRENCY, MAX_NODE_CREDENTIAL_DAYS, MAX_NODE_CREDENTIAL_NAME_LENGTH, MAX_NODE_ELIGIBLE_TYPES, MAX_NODE_VITALS_EXTRA_KEYS, MAX_NODE_VITALS_EXTRA_VALUE, NODE_APP_SPAN_NAME_PATTERN, NODE_HEALTHS, NODE_STATUSES, NODE_VITALS_EXTRA_KEY_PATTERN, } from './constants.js';
+export { adminNodeCredentialSchema, adminNodeSchema, nodeCredentialCreatedSchema, nodeCredentialListItemSchema, nodeJobCountsSchema, nodeOwnerSchema, } from './admin-schemas.js';
+export type { AdminNode, AdminNodeCredential, NodeCredentialCreated, NodeCredentialListItem, NodeHealth, NodeHealthEnum, NodeJobCounts, NodeOwner, NodeStatus, NodeStatusEnum, } from './admin-schemas.js';
+export { claimJobsSchema, claimTokenField, createNodeCredentialSchema, heartbeatNodeSchema, nodeDownloadUrlSchema, nodeJobFailureSchema, nodeJobResultSchema, nodeJobSecretRequestSchema, nodeUploadUrlSchema, nodeVitalsCountersSchema, nodeVitalsExtraSchema, nodeVitalsSchema, registerNodeSchema, renewLeaseSchema, } from './schemas.js';
+export type { NodeReportedStatusEnum, NodeVitals, NodeVitalsCounters, } from './schemas.js';
+export { nodesResponseSchema, nodesSettingsPatchSchema, nodesSettingsSchema, systemNodesPatchSchema, systemNodesSchema, } from './settings-schemas.js';
+export type { NodesSettingsPatchInput, SystemNodesValue } from './settings-schemas.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/nodes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/nodes/index.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,uBAAuB,EACvB,oBAAoB,EACpB,wBAAwB,EACxB,+BAA+B,EAC/B,uBAAuB,EACvB,0BAA0B,EAC1B,2BAA2B,EAC3B,0BAA0B,EAC1B,YAAY,EACZ,aAAa,EACb,6BAA6B,GAC9B,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,yBAAyB,EACzB,eAAe,EACf,2BAA2B,EAC3B,4BAA4B,EAC5B,mBAAmB,EACnB,eAAe,GAChB,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EACV,SAAS,EACT,mBAAmB,EACnB,qBAAqB,EACrB,sBAAsB,EACtB,UAAU,EACV,cAAc,EACd,aAAa,EACb,SAAS,EACT,UAAU,EACV,cAAc,GACf,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,eAAe,EACf,eAAe,EACf,0BAA0B,EAC1B,mBAAmB,EACnB,qBAAqB,EACrB,oBAAoB,EACpB,mBAAmB,EACnB,0BAA0B,EAC1B,mBAAmB,EACnB,wBAAwB,EACxB,qBAAqB,EACrB,gBAAgB,EAChB,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,cAAc,CAAC;AACtB,YAAY,EACV,sBAAsB,EACtB,UAAU,EACV,kBAAkB,GACnB,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,mBAAmB,EACnB,wBAAwB,EACxB,mBAAmB,EACnB,sBAAsB,EACtB,iBAAiB,GAClB,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/cjs/nodes/index.js

@@ -0,0 +1,50 @@
+"use strict";
+// `@marinoscar/platform-contract/nodes`: the node routes' request shapes,
+// shared by `@marinoscar/platform-api/nodes` (its DTOs wrap these schemas) and
+// node clients (issue #734, PP-8.2). Documented in ./README.md. Explicit
+// named exports only. constants.ts is zod-free.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.systemNodesSchema = exports.systemNodesPatchSchema = exports.nodesSettingsSchema = exports.nodesSettingsPatchSchema = exports.nodesResponseSchema = exports.renewLeaseSchema = exports.registerNodeSchema = exports.nodeVitalsSchema = exports.nodeVitalsExtraSchema = exports.nodeVitalsCountersSchema = exports.nodeUploadUrlSchema = exports.nodeJobSecretRequestSchema = exports.nodeJobResultSchema = exports.nodeJobFailureSchema = exports.nodeDownloadUrlSchema = exports.heartbeatNodeSchema = exports.createNodeCredentialSchema = exports.claimTokenField = exports.claimJobsSchema = exports.nodeOwnerSchema = exports.nodeJobCountsSchema = exports.nodeCredentialListItemSchema = exports.nodeCredentialCreatedSchema = exports.adminNodeSchema = exports.adminNodeCredentialSchema = exports.NODE_VITALS_EXTRA_KEY_PATTERN = exports.NODE_STATUSES = exports.NODE_HEALTHS = exports.NODE_APP_SPAN_NAME_PATTERN = exports.MAX_NODE_VITALS_EXTRA_VALUE = exports.MAX_NODE_VITALS_EXTRA_KEYS = exports.MAX_NODE_ELIGIBLE_TYPES = exports.MAX_NODE_CREDENTIAL_NAME_LENGTH = exports.MAX_NODE_CREDENTIAL_DAYS = exports.MAX_NODE_CONCURRENCY = exports.BUILTIN_NODE_SPAN_NAMES = void 0;
+var constants_js_1 = require("./constants.js");
+Object.defineProperty(exports, "BUILTIN_NODE_SPAN_NAMES", { enumerable: true, get: function () { return constants_js_1.BUILTIN_NODE_SPAN_NAMES; } });
+Object.defineProperty(exports, "MAX_NODE_CONCURRENCY", { enumerable: true, get: function () { return constants_js_1.MAX_NODE_CONCURRENCY; } });
+Object.defineProperty(exports, "MAX_NODE_CREDENTIAL_DAYS", { enumerable: true, get: function () { return constants_js_1.MAX_NODE_CREDENTIAL_DAYS; } });
+Object.defineProperty(exports, "MAX_NODE_CREDENTIAL_NAME_LENGTH", { enumerable: true, get: function () { return constants_js_1.MAX_NODE_CREDENTIAL_NAME_LENGTH; } });
+Object.defineProperty(exports, "MAX_NODE_ELIGIBLE_TYPES", { enumerable: true, get: function () { return constants_js_1.MAX_NODE_ELIGIBLE_TYPES; } });
+Object.defineProperty(exports, "MAX_NODE_VITALS_EXTRA_KEYS", { enumerable: true, get: function () { return constants_js_1.MAX_NODE_VITALS_EXTRA_KEYS; } });
+Object.defineProperty(exports, "MAX_NODE_VITALS_EXTRA_VALUE", { enumerable: true, get: function () { return constants_js_1.MAX_NODE_VITALS_EXTRA_VALUE; } });
+Object.defineProperty(exports, "NODE_APP_SPAN_NAME_PATTERN", { enumerable: true, get: function () { return constants_js_1.NODE_APP_SPAN_NAME_PATTERN; } });
+Object.defineProperty(exports, "NODE_HEALTHS", { enumerable: true, get: function () { return constants_js_1.NODE_HEALTHS; } });
+Object.defineProperty(exports, "NODE_STATUSES", { enumerable: true, get: function () { return constants_js_1.NODE_STATUSES; } });
+Object.defineProperty(exports, "NODE_VITALS_EXTRA_KEY_PATTERN", { enumerable: true, get: function () { return constants_js_1.NODE_VITALS_EXTRA_KEY_PATTERN; } });
+// ---- ./admin-schemas.ts: the admin fleet's response shapes (#881)
+var admin_schemas_js_1 = require("./admin-schemas.js");
+Object.defineProperty(exports, "adminNodeCredentialSchema", { enumerable: true, get: function () { return admin_schemas_js_1.adminNodeCredentialSchema; } });
+Object.defineProperty(exports, "adminNodeSchema", { enumerable: true, get: function () { return admin_schemas_js_1.adminNodeSchema; } });
+Object.defineProperty(exports, "nodeCredentialCreatedSchema", { enumerable: true, get: function () { return admin_schemas_js_1.nodeCredentialCreatedSchema; } });
+Object.defineProperty(exports, "nodeCredentialListItemSchema", { enumerable: true, get: function () { return admin_schemas_js_1.nodeCredentialListItemSchema; } });
+Object.defineProperty(exports, "nodeJobCountsSchema", { enumerable: true, get: function () { return admin_schemas_js_1.nodeJobCountsSchema; } });
+Object.defineProperty(exports, "nodeOwnerSchema", { enumerable: true, get: function () { return admin_schemas_js_1.nodeOwnerSchema; } });
+var schemas_js_1 = require("./schemas.js");
+Object.defineProperty(exports, "claimJobsSchema", { enumerable: true, get: function () { return schemas_js_1.claimJobsSchema; } });
+Object.defineProperty(exports, "claimTokenField", { enumerable: true, get: function () { return schemas_js_1.claimTokenField; } });
+Object.defineProperty(exports, "createNodeCredentialSchema", { enumerable: true, get: function () { return schemas_js_1.createNodeCredentialSchema; } });
+Object.defineProperty(exports, "heartbeatNodeSchema", { enumerable: true, get: function () { return schemas_js_1.heartbeatNodeSchema; } });
+Object.defineProperty(exports, "nodeDownloadUrlSchema", { enumerable: true, get: function () { return schemas_js_1.nodeDownloadUrlSchema; } });
+Object.defineProperty(exports, "nodeJobFailureSchema", { enumerable: true, get: function () { return schemas_js_1.nodeJobFailureSchema; } });
+Object.defineProperty(exports, "nodeJobResultSchema", { enumerable: true, get: function () { return schemas_js_1.nodeJobResultSchema; } });
+Object.defineProperty(exports, "nodeJobSecretRequestSchema", { enumerable: true, get: function () { return schemas_js_1.nodeJobSecretRequestSchema; } });
+Object.defineProperty(exports, "nodeUploadUrlSchema", { enumerable: true, get: function () { return schemas_js_1.nodeUploadUrlSchema; } });
+Object.defineProperty(exports, "nodeVitalsCountersSchema", { enumerable: true, get: function () { return schemas_js_1.nodeVitalsCountersSchema; } });
+Object.defineProperty(exports, "nodeVitalsExtraSchema", { enumerable: true, get: function () { return schemas_js_1.nodeVitalsExtraSchema; } });
+Object.defineProperty(exports, "nodeVitalsSchema", { enumerable: true, get: function () { return schemas_js_1.nodeVitalsSchema; } });
+Object.defineProperty(exports, "registerNodeSchema", { enumerable: true, get: function () { return schemas_js_1.registerNodeSchema; } });
+Object.defineProperty(exports, "renewLeaseSchema", { enumerable: true, get: function () { return schemas_js_1.renewLeaseSchema; } });
+// ---- ./settings-schemas.ts: the `nodes` system-settings namespace (#865)
+var settings_schemas_js_1 = require("./settings-schemas.js");
+Object.defineProperty(exports, "nodesResponseSchema", { enumerable: true, get: function () { return settings_schemas_js_1.nodesResponseSchema; } });
+Object.defineProperty(exports, "nodesSettingsPatchSchema", { enumerable: true, get: function () { return settings_schemas_js_1.nodesSettingsPatchSchema; } });
+Object.defineProperty(exports, "nodesSettingsSchema", { enumerable: true, get: function () { return settings_schemas_js_1.nodesSettingsSchema; } });
+Object.defineProperty(exports, "systemNodesPatchSchema", { enumerable: true, get: function () { return settings_schemas_js_1.systemNodesPatchSchema; } });
+Object.defineProperty(exports, "systemNodesSchema", { enumerable: true, get: function () { return settings_schemas_js_1.systemNodesSchema; } });
+//# sourceMappingURL=index.js.map

package/dist/cjs/nodes/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/nodes/index.ts"],"names":[],"mappings":";AAAA,0EAA0E;AAC1E,+EAA+E;AAC/E,yEAAyE;AACzE,gDAAgD;;;AAEhD,+CAYwB;AAXtB,uHAAA,uBAAuB,OAAA;AACvB,oHAAA,oBAAoB,OAAA;AACpB,wHAAA,wBAAwB,OAAA;AACxB,+HAAA,+BAA+B,OAAA;AAC/B,uHAAA,uBAAuB,OAAA;AACvB,0HAAA,0BAA0B,OAAA;AAC1B,2HAAA,2BAA2B,OAAA;AAC3B,0HAAA,0BAA0B,OAAA;AAC1B,4GAAA,YAAY,OAAA;AACZ,6GAAA,aAAa,OAAA;AACb,6HAAA,6BAA6B,OAAA;AAE/B,oEAAoE;AACpE,uDAO4B;AAN1B,6HAAA,yBAAyB,OAAA;AACzB,mHAAA,eAAe,OAAA;AACf,+HAAA,2BAA2B,OAAA;AAC3B,gIAAA,4BAA4B,OAAA;AAC5B,uHAAA,mBAAmB,OAAA;AACnB,mHAAA,eAAe,OAAA;AAcjB,2CAesB;AAdpB,6GAAA,eAAe,OAAA;AACf,6GAAA,eAAe,OAAA;AACf,wHAAA,0BAA0B,OAAA;AAC1B,iHAAA,mBAAmB,OAAA;AACnB,mHAAA,qBAAqB,OAAA;AACrB,kHAAA,oBAAoB,OAAA;AACpB,iHAAA,mBAAmB,OAAA;AACnB,wHAAA,0BAA0B,OAAA;AAC1B,iHAAA,mBAAmB,OAAA;AACnB,sHAAA,wBAAwB,OAAA;AACxB,mHAAA,qBAAqB,OAAA;AACrB,8GAAA,gBAAgB,OAAA;AAChB,gHAAA,kBAAkB,OAAA;AAClB,8GAAA,gBAAgB,OAAA;AAQlB,2EAA2E;AAC3E,6DAM+B;AAL7B,0HAAA,mBAAmB,OAAA;AACnB,+HAAA,wBAAwB,OAAA;AACxB,0HAAA,mBAAmB,OAAA;AACnB,6HAAA,sBAAsB,OAAA;AACtB,wHAAA,iBAAiB,OAAA"}

package/dist/cjs/nodes/schemas.d.ts

@@ -0,0 +1,332 @@
+import { z } from 'zod';
+/**
+ * The entries of the status a node may report about itself.
+ *
+ * @stability experimental
+ */
+export type NodeReportedStatusEnum = {
+    [K in 'online' | 'offline']: K;
+};
+/**
+ * THE CLAIM THIS MESSAGE IS ABOUT — `jobs.claim_token`, handed to the node in
+ * the claim response and quoted back on every route that speaks for a held
+ * job (#364).
+ *
+ * WHY A NODE ID IS NOT ENOUGH, which is the whole of this field. Every guard
+ * on the six routes above identified the caller by `claimedByNodeId` alone,
+ * which tells one node from another and NOT ONE NODE FROM ITSELF. A node that
+ * claims job J, stalls past its lease, is reaped, and then claims J again in a
+ * second worker slot has two live slots quoting the same node id, and every
+ * one of those six routes will believe the older one:
+ *
+ *   - `renew` — the stale slot extends the lease its OWN newer claim is
+ *     running under, so a second slot that dies is reaped late, for as long as
+ *     the first keeps ticking.
+ *   - `result` / `failure` — the stale slot SETTLES a job its newer claim is
+ *     still executing, persisting output computed against an earlier attempt
+ *     or charging a failure against a run that is going fine.
+ *   - `upload-url` — the sharpest of the six, and the quietest. With
+ *     `deriveOutputKey` (#348) the key is a function of the JOB, not of the
+ *     claim, so a stale slot is handed a signed PUT for the exact output key
+ *     its own later claim is currently writing. Both PUTs "succeed"; the
+ *     bytes that survive are whichever finished last, and nothing anywhere
+ *     records that two ran.
+ *   - `download-url` — a bearer capability for the job's input, minted for a
+ *     slot that no longer holds the row.
+ *   - `secret` — a LIVE DATABASE CREDENTIAL handed to a slot that lost the
+ *     job, valid for the lease of a claim that is not its own.
+ *
+ * The token is minted per row by the claim statement
+ * (`job-claim.service.ts`, `gen_random_uuid()`), so those two claims carry
+ * different tokens and the stale one is refused.
+ *
+ * ⚠ OPTIONAL ON THE WIRE EVERYWHERE, AND THAT IS LOAD-BEARING, not politeness.
+ * A fleet is upgraded one machine at a time; a node running older CLI code
+ * omits this field, and the server must then behave EXACTLY as it did before —
+ * the node id and the lease alone — rather than 400 the request or 409 the
+ * job. Same posture as `renewIntervalMs` in #347: additive, ignorable,
+ * strictly better when present. The ambiguity above stays open for that node
+ * until it is upgraded, which is a rolling-upgrade window rather than a new
+ * hole; nothing the server can do closes it earlier, because the only value
+ * able to tell two slots of one node apart is one only they hold.
+ *
+ * ⚠ OMITTED MUST STAY `undefined` AND MUST NOT BECOME `null`. Downstream this
+ * value reaches `heldLeaseWhere`, where the two mean opposite things:
+ * `undefined` drops the clause entirely ("I am not asserting a claim"), while
+ * `null` matches `claim_token IS NULL` ("I assert this row carries no token",
+ * which is what a claim taken before the column existed looks like).
+ * `.optional()` with no `.nullable()` is what keeps them apart — a body that
+ * spells the key as `null` is refused rather than silently reinterpreted as
+ * the other statement. Apply `.optional()` at each use site rather than baking
+ * it in here, so every body says out loud that the field may be absent.
+ *
+ * Validated as a uuid rather than as any bounded string because the column is
+ * `uuid`: a garbage value reaching a `where` clause is a Postgres cast error
+ * (a 500 about "inconsistent column data"), and a clean 400 naming the field
+ * is a better answer to a malformed token than a 500 is.
+ *
+ * @stability experimental
+ */
+export declare const claimTokenField: z.ZodUUID;
+/**
+ * The body that mints a node credential (`nod_` token).
+ *
+ * @stability experimental
+ */
+export declare const createNodeCredentialSchema: z.ZodObject<{
+    name: z.ZodString;
+    expiresInDays: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Cumulative counters since the node process started; reset on restart.
+ *
+ * @stability experimental
+ */
+export declare const nodeVitalsCountersSchema: z.ZodObject<{
+    claims: z.ZodOptional<z.ZodNumber>;
+    emptyPolls: z.ZodOptional<z.ZodNumber>;
+    claimFailures: z.ZodOptional<z.ZodNumber>;
+    succeeded: z.ZodOptional<z.ZodNumber>;
+    failed: z.ZodOptional<z.ZodNumber>;
+    rateLimited: z.ZodOptional<z.ZodNumber>;
+    leaseRenewals: z.ZodOptional<z.ZodNumber>;
+    leaseRenewFailures: z.ZodOptional<z.ZodNumber>;
+    heartbeatFailures: z.ZodOptional<z.ZodNumber>;
+    watchdogTrips: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+/**
+ * App-defined numeric vitals: a bounded bag of `key -> number` an executor or
+ * the node's app reports beyond the closed fields (a transcoder's frames per
+ * second, a GPU's temperature). Still CLOSED IN SHAPE: at most
+ * {@link MAX_NODE_VITALS_EXTRA_KEYS} keys, each key matching
+ * {@link NODE_VITALS_EXTRA_KEY_PATTERN}, each value a finite number within
+ * +/-{@link MAX_NODE_VITALS_EXTRA_VALUE}. No strings, no nesting, so it stays
+ * the unbounded-JSONB-write-free surface the closed fields are. The CLI drops
+ * what would not pass before sending (a heartbeat the server refuses costs the
+ * node its liveness signal), and the fleet page labels a key through
+ * `registerNodeVital`.
+ *
+ * @stability experimental
+ */
+export declare const nodeVitalsExtraSchema: z.ZodRecord<z.ZodString, z.ZodNumber>;
+/**
+ * A node's health snapshot, carried on its heartbeat; closed and bounded.
+ *
+ * @stability experimental
+ */
+export declare const nodeVitalsSchema: z.ZodObject<{
+    cpuPercent: z.ZodOptional<z.ZodNumber>;
+    rssBytes: z.ZodOptional<z.ZodNumber>;
+    heapUsedBytes: z.ZodOptional<z.ZodNumber>;
+    heapLimitBytes: z.ZodOptional<z.ZodNumber>;
+    eventLoopDelayP99Ms: z.ZodOptional<z.ZodNumber>;
+    stateDirFreeBytes: z.ZodOptional<z.ZodNumber>;
+    stateDirTotalBytes: z.ZodOptional<z.ZodNumber>;
+    slotsUsed: z.ZodOptional<z.ZodNumber>;
+    slotsTotal: z.ZodOptional<z.ZodNumber>;
+    uptimeSeconds: z.ZodOptional<z.ZodNumber>;
+    counters: z.ZodOptional<z.ZodObject<{
+        claims: z.ZodOptional<z.ZodNumber>;
+        emptyPolls: z.ZodOptional<z.ZodNumber>;
+        claimFailures: z.ZodOptional<z.ZodNumber>;
+        succeeded: z.ZodOptional<z.ZodNumber>;
+        failed: z.ZodOptional<z.ZodNumber>;
+        rateLimited: z.ZodOptional<z.ZodNumber>;
+        leaseRenewals: z.ZodOptional<z.ZodNumber>;
+        leaseRenewFailures: z.ZodOptional<z.ZodNumber>;
+        heartbeatFailures: z.ZodOptional<z.ZodNumber>;
+        watchdogTrips: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    cliVersion: z.ZodOptional<z.ZodString>;
+    nodeVersion: z.ZodOptional<z.ZodString>;
+    pgDumpVersion: z.ZodOptional<z.ZodString>;
+    extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+}, z.core.$strict>;
+/**
+ * The parsed vitals snapshot.
+ *
+ * @stability experimental
+ */
+export type NodeVitals = z.infer<typeof nodeVitalsSchema>;
+/**
+ * The parsed vitals counters.
+ *
+ * @stability experimental
+ */
+export type NodeVitalsCounters = z.infer<typeof nodeVitalsCountersSchema>;
+/**
+ * The body of `POST /api/nodes/register`.
+ *
+ * @stability experimental
+ */
+export declare const registerNodeSchema: z.ZodObject<{
+    name: z.ZodString;
+    hostname: z.ZodString;
+    platform: z.ZodString;
+    cliVersion: z.ZodString;
+    eligibleTypes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    concurrency: z.ZodNumber;
+    capabilities: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+/**
+ * The body of `POST /api/nodes/:id/heartbeat`.
+ *
+ * @stability experimental
+ */
+export declare const heartbeatNodeSchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodEnum<NodeReportedStatusEnum>>;
+    concurrency: z.ZodOptional<z.ZodNumber>;
+    capabilities: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    vitals: z.ZodOptional<z.ZodObject<{
+        cpuPercent: z.ZodOptional<z.ZodNumber>;
+        rssBytes: z.ZodOptional<z.ZodNumber>;
+        heapUsedBytes: z.ZodOptional<z.ZodNumber>;
+        heapLimitBytes: z.ZodOptional<z.ZodNumber>;
+        eventLoopDelayP99Ms: z.ZodOptional<z.ZodNumber>;
+        stateDirFreeBytes: z.ZodOptional<z.ZodNumber>;
+        stateDirTotalBytes: z.ZodOptional<z.ZodNumber>;
+        slotsUsed: z.ZodOptional<z.ZodNumber>;
+        slotsTotal: z.ZodOptional<z.ZodNumber>;
+        uptimeSeconds: z.ZodOptional<z.ZodNumber>;
+        counters: z.ZodOptional<z.ZodObject<{
+            claims: z.ZodOptional<z.ZodNumber>;
+            emptyPolls: z.ZodOptional<z.ZodNumber>;
+            claimFailures: z.ZodOptional<z.ZodNumber>;
+            succeeded: z.ZodOptional<z.ZodNumber>;
+            failed: z.ZodOptional<z.ZodNumber>;
+            rateLimited: z.ZodOptional<z.ZodNumber>;
+            leaseRenewals: z.ZodOptional<z.ZodNumber>;
+            leaseRenewFailures: z.ZodOptional<z.ZodNumber>;
+            heartbeatFailures: z.ZodOptional<z.ZodNumber>;
+            watchdogTrips: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        cliVersion: z.ZodOptional<z.ZodString>;
+        nodeVersion: z.ZodOptional<z.ZodString>;
+        pgDumpVersion: z.ZodOptional<z.ZodString>;
+        extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    }, z.core.$strict>>;
+}, z.core.$strip>;
+/**
+ * The body of `POST /api/nodes/:id/claim`.
+ *
+ * @stability experimental
+ */
+export declare const claimJobsSchema: z.ZodObject<{
+    types: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * ⚠ THIS BODY EXISTS TO CARRY ONE OPTIONAL FIELD, AND IT MUST SURVIVE HAVING
+ * NO BODY AT ALL (#364).
+ *
+ * Until this change the renew route took no body, so every node in every fleet
+ * posts to it with no payload and no `Content-Type` — Fastify hands Nest
+ * `undefined`, and a bare `z.object({...})` would reject that outright and
+ * fail every renewal from every node that has not been upgraded yet. `.default({})`
+ * is what makes "no body" parse to "no assertion", which is the pre-#364
+ * behaviour spelled as data. It is the only reason this is a `ZodDefault` and
+ * not a plain object schema; do not unwrap it.
+ *
+ * REJECTED: coercing a `null` body to `{}` as well. That would quietly turn
+ * "I assert this row has no token" into "I assert nothing", and those are
+ * different statements at the `where` clause (see `claimToken` above).
+ *
+ * @stability experimental
+ */
+export declare const renewLeaseSchema: z.ZodDefault<z.ZodObject<{
+    claimToken: z.ZodOptional<z.ZodUUID>;
+}, z.core.$strip>>;
+/**
+ * The body of `POST /api/nodes/:id/jobs/:jobId/result`.
+ *
+ * @stability experimental
+ */
+export declare const nodeJobResultSchema: z.ZodObject<{
+    type: z.ZodString;
+    result: z.ZodUnknown;
+    claimToken: z.ZodOptional<z.ZodUUID>;
+}, z.core.$strip>;
+/**
+ * The body of `POST /api/nodes/:id/jobs/:jobId/failure`.
+ *
+ * @stability experimental
+ */
+export declare const nodeJobFailureSchema: z.ZodObject<{
+    error: z.ZodString;
+    rateLimited: z.ZodOptional<z.ZodBoolean>;
+    retryAfterMs: z.ZodOptional<z.ZodNumber>;
+    willRetry: z.ZodOptional<z.ZodBoolean>;
+    claimToken: z.ZodOptional<z.ZodUUID>;
+}, z.core.$strip>;
+/**
+ * What a node may say when asking to read its input: which claim is asking,
+ * and nothing else.
+ *
+ * ⚠ `.default({})` IS THE BACKWARD-COMPATIBILITY GUARANTEE, not a convenience.
+ * This route took no body at all until #364, so every node in every fleet
+ * posts to it with no payload and no `Content-Type` — Fastify hands Nest
+ * `undefined`, and a bare `z.object({...})` would reject that outright and
+ * fail every download from every node that has not been upgraded yet. The
+ * default is what makes "no body" parse to "no assertion", which is the
+ * pre-#364 behaviour spelled as data. Do not unwrap it. `nodeUploadUrlSchema`
+ * below and `nodeJobSecretRequestSchema` carry it for the milder version of
+ * the same reason — there, an empty body was always legal.
+ *
+ * A plain object rather than the `z.looseObject` its sibling uses: unknown
+ * keys here are stripped, exactly as they were ignored before this body
+ * existed. The loose-then-refuse-by-name treatment next door exists for `key`,
+ * a field whose silent omission would send a node's bytes somewhere it did not
+ * choose; nothing a node can put in THIS body has ever had an effect, so there
+ * is no misunderstanding to name.
+ *
+ * @stability experimental
+ */
+export declare const nodeDownloadUrlSchema: z.ZodDefault<z.ZodObject<{
+    claimToken: z.ZodOptional<z.ZodUUID>;
+}, z.core.$strip>>;
+/**
+ * What a node may say when asking for somewhere to write.
+ *
+ * ⚠ `z.looseObject` RATHER THAN `z.strictObject`, AND THE REASON IS THE ERROR
+ * MESSAGE. Strict mode rejects an unknown key with a perfectly good Zod issue
+ * naming it — and that issue is then DESTROYED on the way out, because
+ * `http-exception.filter.ts` rebuilds every error body from a fixed key
+ * allowlist (`message`, `code`, `details`) and the validation pipe puts its
+ * issues under `errors`. The node would receive a bare
+ * `400 "Validation failed"`, which for the one field this endpoint most needs
+ * to talk about — `key` — is the least useful answer available.
+ *
+ * So unknown keys are CAPTURED here and refused in
+ * `NodeDataPlaneService.createUploadTarget`, which can raise a
+ * `BadRequestException` carrying a message that names the field, explains that
+ * the server chooses the key, and survives the filter intact. The security
+ * outcome is identical either way (the key is never read); what differs is
+ * whether the node's author is told why.
+ *
+ * `.default({})` so a node with nothing to declare may send an EMPTY BODY
+ * rather than being required to send `{}` to satisfy a parser.
+ *
+ * @stability experimental
+ */
+export declare const nodeUploadUrlSchema: z.ZodDefault<z.ZodObject<{
+    contentType: z.ZodOptional<z.ZodString>;
+    claimToken: z.ZodOptional<z.ZodUUID>;
+}, z.core.$loose>>;
+/**
+ * What a node may say when asking for its job's credential: which claim is
+ * asking, and nothing else.
+ *
+ * `.default({})` so a node with nothing to declare may send an empty body
+ * rather than being made to send `{}` to satisfy a parser — an empty body is
+ * still a correct request, and is what every node sent before #364. Anything
+ * beyond `claimToken` is captured by the loose object and refused by name in
+ * the service, whose allowlist — not this schema — is the authority on what
+ * may be sent; adding a field here without adding it there would 400 the
+ * clients that send it.
+ *
+ * @stability experimental
+ */
+export declare const nodeJobSecretRequestSchema: z.ZodDefault<z.ZodObject<{
+    claimToken: z.ZodOptional<z.ZodUUID>;
+}, z.core.$loose>>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/cjs/nodes/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/nodes/schemas.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAYxB;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG;KAAG,CAAC,IAAI,QAAQ,GAAG,SAAS,GAAG,CAAC;CAAE,CAAC;AA6BxE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,eAAO,MAAM,eAAe,WAa3B,CAAC;AAmCF;;;;GAIG;AACH,eAAO,MAAM,0BAA0B;;;iBAqBrC,CAAC;AA0MH;;;;GAIG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;kBAuB1B,CAAC;AAEZ;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,qBAAqB,uCAI9B,CAAC;AAEL;;;;GAIG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAiClB,CAAC;AAEZ;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAM1E;;;;GAIG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;iBAkC7B,CAAC;AAMH;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwB9B,CAAC;AAMH;;;;GAIG;AACH,eAAO,MAAM,eAAe;;;iBAoB1B,CAAC;AAMH;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,gBAAgB;;kBAKf,CAAC;AAMf;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;;;;iBAmC9B,CAAC;AAMH;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;;;;;;iBAqC/B,CAAC;AAyGH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,qBAAqB;;kBAKpB,CAAC;AAMf;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,mBAAmB;;;kBAsClB,CAAC;AA+Ef;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,0BAA0B;;kBAKzB,CAAC"}