@serve.zone/interfaces 31.7.0 → 31.9.0

package/dist_ts/data/serviceruntime.d.ts

@@ -0,0 +1,128 @@
+import type { IRuntimeAssignmentObservationV1, IRuntimeAssignmentReferenceV1, TRuntimeAssignmentDispositionV1 } from './runtimeassignment.js';
+import type { IRuntimeConfigLogPolicyV1, TRuntimeConfigReadinessV1 } from './runtimeconfig.js';
+/** `nodes` pins the service to exactly these nodes: sorted, unique and never empty. */
+export type TServiceRuntimePlacement = {
+    kind: 'every-node';
+} | {
+    kind: 'nodes';
+    nodeIds: string[];
+};
+/**
+ * The execution policy a service's runtime configs are built with. It carries everything the
+ * runtime config seals except what only the service and its image supply: environment, working
+ * directory and target ports. A readiness probe names a target port, which the runtime config then
+ * requires the service to declare.
+ */
+export interface IServiceRuntimeProfile {
+    /** null explicitly requests no CPU quota. */
+    cpuMillis: number | null;
+    memoryBytes: number;
+    readiness: TRuntimeConfigReadinessV1;
+    logs: IRuntimeConfigLogPolicyV1;
+    readonlyRootfs: boolean;
+    /** null runs the image's own OCI user, exactly as a runtime config's null identity pair does. */
+    runAs: {
+        user: number;
+        group: number;
+    } | null;
+}
+/**
+ * `isolated` gives the workload no network authority. `attached` joins the runtime network with
+ * public egress on or off and the platform endpoints it may reach, by id: sorted and unique.
+ */
+export type TServiceRuntimeNetwork = {
+    mode: 'isolated';
+} | {
+    mode: 'attached';
+    publicEgress: boolean;
+    platformEndpointIds: string[];
+};
+/**
+ * What Cloudly runs for one service on a Pallet cluster. Stored complete, never defaulted at read
+ * time, and beside the service document rather than inside it, so a hold written by a cutover
+ * never races an operator's service edit.
+ */
+export interface IServiceRuntimeSpec {
+    /** The service id. */
+    id: string;
+    /** The service's organization, copied by Cloudly; never caller-chosen. */
+    organizationId: string;
+    clusterId: string;
+    placement: TServiceRuntimePlacement;
+    replicasPerNode: number;
+    /** While true, the service runs nowhere and every slot keeps its storage. */
+    hold: boolean;
+    profile: IServiceRuntimeProfile;
+    network: TServiceRuntimeNetwork;
+    /** Compare-and-swap counter; every write advances it by one. */
+    revision: number;
+}
+/** What an administrator writes; Cloudly supplies the service id, organization and revision. */
+export type TServiceRuntimeSpecWritableData = Omit<IServiceRuntimeSpec, 'id' | 'organizationId' | 'revision'>;
+export declare const serviceRuntimeContract: Readonly<{
+    readonly maximumReplicasPerNode: 64;
+    /** A service whose placement desires more replicas than this is refused as `replica-limit`. */
+    readonly maximumReplicas: 64;
+    /** A node can run workloads only as an egress member of the protected authority, which admits at most this many. */
+    readonly maximumPinnedNodes: 256;
+    readonly maximumPlatformEndpoints: 64;
+    /** The largest `limit` `getClusterRuntimeAssignments` accepts; Cloudly refuses a larger one. */
+    readonly maximumAssignmentPageSize: 256;
+}>;
+declare const serviceRuntimeWaitingReasons: readonly ["node-network-pending", "conflict", "failure-backoff"];
+declare const serviceRuntimeRefusals: readonly ["cluster-runtime-missing", "organization-missing", "image-plan-missing", "platform-unsupported", "secrets-unsupported", "volumes-unsupported", "port-protocol-unsupported", "readiness-target-undeclared", "environment-too-large", "no-eligible-node", "replica-limit"];
+/**
+ * Why the producer is not converging yet, though nothing needs an administrator:
+ * `node-network-pending` waits for a node's network readiness, `conflict` for a sweep over inputs
+ * that changed while it ran, `failure-backoff` for a failed replica's backoff to elapse.
+ */
+export type TServiceRuntimeWaitingReason = typeof serviceRuntimeWaitingReasons[number];
+/** Why the producer admits nothing for this spec revision. A refusal never retires running slots. */
+export type TServiceRuntimeRefusal = typeof serviceRuntimeRefusals[number];
+interface IServiceRuntimeStatusBase {
+    /** The service id. */
+    id: string;
+    /** The spec revision this verdict is about. */
+    specRevision: number;
+    /** Unix milliseconds on Cloudly's clock. Written only when the verdict changes. */
+    changedAt: number;
+}
+/** The producer's verdict on one spec revision. */
+export type IServiceRuntimeStatus = IServiceRuntimeStatusBase & ({
+    state: 'converged' | 'converging';
+    reason: null;
+} | {
+    state: 'waiting';
+    reason: TServiceRuntimeWaitingReason;
+} | {
+    state: 'refused';
+    reason: TServiceRuntimeRefusal;
+});
+/**
+ * `delivered` once the node's own evidence, an observation or a terminal receipt, cites this exact
+ * revision; `undelivered` until then. Cloudly keeps no acknowledgement journal, so a revision the
+ * node admitted but has not yet reported on reads as undelivered.
+ */
+export type TServiceRuntimeAssignmentDelivery = 'undelivered' | 'delivered';
+/** One replica slot's current assignment, as an administrator reads it. */
+export interface IServiceRuntimeAssignmentView {
+    serviceId: string;
+    replicaId: string;
+    nodeId: string;
+    /** The current revision; its generation is the one the disposition belongs to. */
+    assignment: IRuntimeAssignmentReferenceV1;
+    disposition: TRuntimeAssignmentDispositionV1;
+    /** The latest accepted observation of this attempt, which may cite an earlier revision. */
+    observation: Pick<IRuntimeAssignmentObservationV1, 'phase' | 'ready' | 'observedAt' | 'sequence'> | null;
+    /** Joined stop and remove receipts of this attempt. */
+    terminalReceiptCount: 0 | 1 | 2;
+    delivery: TServiceRuntimeAssignmentDelivery;
+}
+/**
+ * Structural snapshot for exact persistence and for a spec write. Whether the cluster, the nodes and
+ * the platform endpoints exist, and whether the service declares the readiness target, is Cloudly's.
+ */
+export declare const snapshotServiceRuntimeSpec: (value: unknown) => IServiceRuntimeSpec;
+/** Structural snapshot for exact persistence: a reason belongs to exactly one state. */
+export declare const snapshotServiceRuntimeStatus: (value: unknown) => IServiceRuntimeStatus;
+export {};

package/dist_ts/data/serviceruntime.js

@@ -0,0 +1,92 @@
+import { runtimeNetworkAuthorityV1Contract } from './networkauthority.js';
+import { captureNetwork, networkCanonical, networkCounter, networkId, networkList, networkRecord, networkSorted, requireNetwork } from '../private/networkcontract.js';
+import { failProducer, isOneOf, producerSafe, variantOf } from '../private/producercontract.js';
+import { assertRuntimeReadiness, isBoundedInteger, isRuntimeCpuMillis, isRuntimeIdentityNumber, isRuntimeLogPolicy, isRuntimeMemoryBytes } from '../private/runtimepolicy.js';
+export const serviceRuntimeContract = Object.freeze({
+    maximumReplicasPerNode: 64,
+    /** A service whose placement desires more replicas than this is refused as `replica-limit`. */
+    maximumReplicas: 64,
+    /** A node can run workloads only as an egress member of the protected authority, which admits at most this many. */
+    maximumPinnedNodes: runtimeNetworkAuthorityV1Contract.maximumEgressAuthorities,
+    maximumPlatformEndpoints: runtimeNetworkAuthorityV1Contract.maximumPlatformEndpoints,
+    /** The largest `limit` `getClusterRuntimeAssignments` accepts; Cloudly refuses a larger one. */
+    maximumAssignmentPageSize: 256,
+});
+const serviceRuntimeWaitingReasons = ['node-network-pending', 'conflict', 'failure-backoff'];
+const serviceRuntimeRefusals = [
+    'cluster-runtime-missing', 'organization-missing', 'image-plan-missing', 'platform-unsupported',
+    'secrets-unsupported', 'volumes-unsupported', 'port-protocol-unsupported', 'readiness-target-undeclared',
+    'environment-too-large', 'no-eligible-node', 'replica-limit',
+];
+const sortedIds = (value, maximum) => networkSorted(networkList(value, maximum, networkId), id => id);
+const placementOf = (value) => {
+    const kind = variantOf(value, 'kind');
+    if (kind === 'every-node') {
+        networkRecord(value, ['kind']);
+        return { kind };
+    }
+    requireNetwork(kind === 'nodes');
+    const nodeIds = sortedIds(networkRecord(value, ['kind', 'nodeIds']).nodeIds, serviceRuntimeContract.maximumPinnedNodes);
+    requireNetwork(nodeIds.length > 0);
+    return { kind, nodeIds };
+};
+const runAsOf = (value) => {
+    if (value === null)
+        return null;
+    const item = networkRecord(value, ['user', 'group']);
+    requireNetwork(isRuntimeIdentityNumber(item.user) && isRuntimeIdentityNumber(item.group));
+    return { user: item.user, group: item.group };
+};
+const profileOf = (value) => {
+    const item = networkRecord(value, ['cpuMillis', 'memoryBytes', 'readiness', 'logs', 'readonlyRootfs', 'runAs']);
+    requireNetwork(isRuntimeCpuMillis(item.cpuMillis) && isRuntimeMemoryBytes(item.memoryBytes)
+        && isRuntimeLogPolicy(item.logs) && typeof item.readonlyRootfs === 'boolean');
+    // The profile precedes the service's target ports; the runtime config refuses a target they do not declare.
+    assertRuntimeReadiness(item.readiness, () => true, failProducer);
+    const { maximumLineBytes, maximumBufferedBytes, retentionMs } = item.logs;
+    return { cpuMillis: item.cpuMillis, memoryBytes: item.memoryBytes,
+        readiness: JSON.parse(networkCanonical(item.readiness)),
+        logs: { maximumLineBytes, maximumBufferedBytes, retentionMs }, readonlyRootfs: item.readonlyRootfs, runAs: runAsOf(item.runAs) };
+};
+const networkOf = (value) => {
+    const mode = variantOf(value, 'mode');
+    if (mode === 'isolated') {
+        networkRecord(value, ['mode']);
+        return { mode };
+    }
+    requireNetwork(mode === 'attached');
+    const item = networkRecord(value, ['mode', 'publicEgress', 'platformEndpointIds']);
+    requireNetwork(typeof item.publicEgress === 'boolean');
+    return { mode, publicEgress: item.publicEgress,
+        platformEndpointIds: sortedIds(item.platformEndpointIds, serviceRuntimeContract.maximumPlatformEndpoints) };
+};
+/**
+ * Structural snapshot for exact persistence and for a spec write. Whether the cluster, the nodes and
+ * the platform endpoints exist, and whether the service declares the readiness target, is Cloudly's.
+ */
+export const snapshotServiceRuntimeSpec = (value) => producerSafe(() => {
+    const item = networkRecord(captureNetwork(value), ['id', 'organizationId', 'clusterId', 'placement',
+        'replicasPerNode', 'hold', 'profile', 'network', 'revision']);
+    requireNetwork(isBoundedInteger(item.replicasPerNode, 1, serviceRuntimeContract.maximumReplicasPerNode)
+        && typeof item.hold === 'boolean');
+    return { id: networkId(item.id), organizationId: networkId(item.organizationId), clusterId: networkId(item.clusterId),
+        placement: placementOf(item.placement), replicasPerNode: item.replicasPerNode, hold: item.hold,
+        profile: profileOf(item.profile), network: networkOf(item.network), revision: networkCounter(item.revision) };
+});
+/** Structural snapshot for exact persistence: a reason belongs to exactly one state. */
+export const snapshotServiceRuntimeStatus = (value) => producerSafe(() => {
+    const item = networkRecord(captureNetwork(value), ['id', 'specRevision', 'state', 'reason', 'changedAt']);
+    const base = { id: networkId(item.id), specRevision: networkCounter(item.specRevision),
+        changedAt: networkCounter(item.changedAt) };
+    if (item.state === 'converged' || item.state === 'converging') {
+        requireNetwork(item.reason === null);
+        return { ...base, state: item.state, reason: null };
+    }
+    if (item.state === 'waiting') {
+        requireNetwork(isOneOf(serviceRuntimeWaitingReasons, item.reason));
+        return { ...base, state: item.state, reason: item.reason };
+    }
+    requireNetwork(item.state === 'refused' && isOneOf(serviceRuntimeRefusals, item.reason));
+    return { ...base, state: item.state, reason: item.reason };
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/private/networkcontract.d.ts

@@ -1,5 +1,7 @@
 import type { TSha256Digest } from '../data/immutableimage.js';
 import type { IRuntimeAuthorityReferenceV1, IRuntimeControllerV1 } from '../data/runtimeassignment.js';
+import type { IRuntimeNetworkDnsLeaseRenewal } from '../data/networklease.js';
+import type { IRuntimeNetworkDnsWindow, IRuntimeNetworkNodeScopeV1, IRuntimeNetworkProjectionV1 } from '../data/networkprojection.js';
 export declare const failNetwork: () => never;
 export declare function requireNetwork(value: unknown): asserts value;
 export declare const networkCanonical: (value: unknown) => string;
@@ -13,9 +15,23 @@ export declare const networkSorted: <T>(values: T[], key: (item: T) => string) =
 export declare const networkId: (value: unknown) => string;
 export declare const networkCounter: (value: unknown, maximum?: number) => number;
 export declare const networkDigest: (value: unknown) => TSha256Digest;
+/** One encoding for every Ed25519 signature this contract carries: lowercase hex, 64 bytes. */
+export declare const networkSignature: (value: unknown) => string;
 export declare const networkController: (value: unknown) => IRuntimeControllerV1;
+export declare const networkScope: (item: Record<string, unknown>) => IRuntimeNetworkNodeScopeV1;
+export declare const networkSameScope: (left: IRuntimeNetworkNodeScopeV1, right: IRuntimeNetworkNodeScopeV1) => boolean;
+export declare const networkMaximumDnsLeaseMs = 900000;
+/** One rule for every signed DNS window, projection or renewal: ordered, non-empty, at most fifteen minutes. */
+export declare const networkDnsWindow: (value: unknown) => IRuntimeNetworkDnsWindow;
 export declare const networkReference: (value: unknown) => IRuntimeAuthorityReferenceV1;
 export declare const networkReferenceOf: (value: IRuntimeAuthorityReferenceV1) => IRuntimeAuthorityReferenceV1;
+/** A renewal renews exactly one projection: the same node scope and that projection's exact reference. */
+export declare const networkRenewsProjection: (renewal: IRuntimeNetworkDnsLeaseRenewal, projection: IRuntimeNetworkProjectionV1) => boolean;
+/**
+ * The one rule for the DNS window a node may use under a projection: its admitted renewal's, else
+ * the projection's own. Both inputs are already validated caller state; this verifies no signature.
+ */
+export declare const networkEffectiveDnsWindow: (projection: IRuntimeNetworkProjectionV1, renewal: IRuntimeNetworkDnsLeaseRenewal | null) => IRuntimeNetworkDnsWindow;
 export declare const networkRevision: (item: Record<string, unknown>) => {
     id: string;
     generation: number;
@@ -27,5 +43,9 @@ export declare const networkHash: (domain: string, value: {
 export declare const networkIpv4: (value: unknown) => string;
 export declare const networkIpv4Number: (value: string) => number;
 export declare const networkPrefixBounds: (value: string) => [number, number];
+/** A canonical IPv4 prefix: a dotted quad whose host bits are zero. */
+export declare const networkPrefix: (value: unknown) => string;
+/** A canonical prefix inside the RFC 1918 private ranges. */
+export declare const networkPrivatePrefix: (value: unknown) => string;
 export declare const networkContains: (outer: string, inner: string) => boolean;
 export declare const networkOverlaps: (left: string, right: string) => boolean;

package/dist_ts/private/networkcontract.js

@@ -96,16 +96,46 @@ export const networkDigest = (value) => {
     requireNetwork(typeof value === 'string' && /^sha256:[a-f0-9]{64}$/.test(value));
     return value;
 };
+/** One encoding for every Ed25519 signature this contract carries: lowercase hex, 64 bytes. */
+export const networkSignature = (value) => {
+    requireNetwork(typeof value === 'string' && /^[a-f0-9]{128}$/.test(value));
+    return value;
+};
 export const networkController = (value) => {
     const item = networkRecord(value, ['kind', 'id', 'epoch']);
     requireNetwork(item.kind === 'cloudly' || item.kind === 'onebox');
     return { kind: item.kind, id: networkId(item.id), epoch: networkId(item.epoch) };
 };
+export const networkScope = (item) => ({
+    controller: networkController(item.controller), nodeId: networkId(item.nodeId), runtimeNamespace: networkId(item.runtimeNamespace),
+});
+export const networkSameScope = (left, right) => networkEqual(left.controller, right.controller) && left.nodeId === right.nodeId && left.runtimeNamespace === right.runtimeNamespace;
+export const networkMaximumDnsLeaseMs = 900_000;
+/** One rule for every signed DNS window, projection or renewal: ordered, non-empty, at most fifteen minutes. */
+export const networkDnsWindow = (value) => {
+    const item = networkRecord(value, ['issuedAt', 'notBefore', 'expiresAt']);
+    const window = { issuedAt: networkCounter(item.issuedAt), notBefore: networkCounter(item.notBefore), expiresAt: networkCounter(item.expiresAt) };
+    requireNetwork(window.notBefore >= window.issuedAt && window.expiresAt > window.notBefore
+        && window.expiresAt - window.issuedAt <= networkMaximumDnsLeaseMs);
+    return window;
+};
 export const networkReference = (value) => {
     const item = networkRecord(value, ['id', 'generation', 'digest']);
     return { id: networkId(item.id), generation: networkCounter(item.generation), digest: networkDigest(item.digest) };
 };
 export const networkReferenceOf = (value) => ({ id: value.id, generation: value.generation, digest: value.digest });
+/** A renewal renews exactly one projection: the same node scope and that projection's exact reference. */
+export const networkRenewsProjection = (renewal, projection) => networkSameScope(renewal, projection) && networkEqual(renewal.projection, networkReferenceOf(projection));
+/**
+ * The one rule for the DNS window a node may use under a projection: its admitted renewal's, else
+ * the projection's own. Both inputs are already validated caller state; this verifies no signature.
+ */
+export const networkEffectiveDnsWindow = (projection, renewal) => {
+    if (renewal === null)
+        return projection.dns;
+    requireNetwork(networkRenewsProjection(renewal, projection));
+    return renewal.dns;
+};
 export const networkRevision = (item) => {
     const id = networkId(item.id), generation = networkCounter(item.generation);
     const previous = item.previous === null ? null : networkReference(item.previous);
@@ -127,6 +157,20 @@ export const networkPrefixBounds = (value) => {
     const [address, bits] = value.split('/'), first = networkIpv4Number(address);
     return [first, first + 2 ** (32 - Number(bits)) - 1];
 };
+/** A canonical IPv4 prefix: a dotted quad whose host bits are zero. */
+export const networkPrefix = (value) => {
+    requireNetwork(typeof value === 'string' && value.length <= 18);
+    const parts = value.split('/');
+    requireNetwork(parts.length === 2 && /^(?:[0-9]|[12][0-9]|3[0-2])$/.test(parts[1]));
+    requireNetwork(networkIpv4Number(networkIpv4(parts[0])) % 2 ** (32 - Number(parts[1])) === 0);
+    return value;
+};
+/** A canonical prefix inside the RFC 1918 private ranges. */
+export const networkPrivatePrefix = (value) => {
+    const prefix = networkPrefix(value);
+    requireNetwork(['10.0.0.0/8', '172.16.0.0/12', '192.168.0.0/16'].some(range => networkContains(range, prefix)));
+    return prefix;
+};
 export const networkContains = (outer, inner) => {
     const [a, b] = networkPrefixBounds(outer), [c, d] = networkPrefixBounds(inner);
     return a <= c && b >= d;
@@ -135,4 +179,4 @@ export const networkOverlaps = (left, right) => {
     const [a, b] = networkPrefixBounds(left), [c, d] = networkPrefixBounds(right);
     return a <= d && c <= b;
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"networkcontract.js","sourceRoot":"","sources":["../../ts/private/networkcontract.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"networkcontract.js","sourceRoot":"","sources":["../../ts/private/networkcontract.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,sBAAsB,EAAE,4BAA4B,EAAE,MAAM,oBAAoB,CAAC;AAE1F,MAAM,CAAC,MAAM,WAAW,GAAG,GAAU,EAAE,GAAG,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC,CAAC,CAAC,CAAC;AAC9G,MAAM,UAAU,cAAc,CAAC,KAAc,IAAmB,IAAI,CAAC,KAAK;IAAE,WAAW,EAAE,CAAC,CAAC,CAAC;AAC5F,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,KAAc,EAAU,EAAE,CAAC,sBAAsB,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;AACvG,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,IAAa,EAAE,KAAc,EAAW,EAAE,CAAC,gBAAgB,CAAC,IAAI,CAAC,KAAK,gBAAgB,CAAC,KAAK,CAAC,CAAC;AAC3H,MAAM,CAAC,MAAM,WAAW,GAAG,CAAI,SAAkB,EAAK,EAAE,GAAG,IAAI,CAAC;IAAC,OAAO,SAAS,EAAE,CAAC;AAAC,CAAC;AAAC,MAAM,CAAC;IAAC,OAAO,WAAW,EAAE,CAAC;AAAC,CAAC,CAAC,CAAC,CAAC;AAEzH,2FAA2F;AAC3F,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,KAAc,EAAW,EAAE,CAAC,WAAW,CAAC,GAAG,EAAE;IAC1E,MAAM,OAAO,GAAG,IAAI,WAAW,EAAE,EAAE,SAAS,GAAG,IAAI,GAAG,EAAU,CAAC;IACjE,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,CAAC,CAAC;IACzB,MAAM,OAAO,GAAG,CAAC,IAAY,EAAE,EAAE;QAC/B,cAAc,CAAC,IAAI,CAAC,MAAM,IAAI,SAAS,CAAC,CAAC;QACzC,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC;QACrC,cAAc,CAAC,KAAK,IAAI,SAAS,CAAC,CAAC;IACrC,CAAC,CAAC;IACF,MAAM,IAAI,GAAG,CAAC,IAAa,EAAE,KAAa,EAAW,EAAE;QACrD,cAAc,CAAC,EAAE,KAAK,IAAI,MAAM,IAAI,KAAK,IAAI,EAAE,CAAC,CAAC;QACjD,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;YAAC,OAAO,CAAC,IAAI,CAAC,CAAC;YAAC,OAAO,IAAI,CAAC;QAAC,CAAC;QAC7D,IAAI,IAAI,KAAK,IAAI,IAAI,OAAO,IAAI,KAAK,SAAS;YAAE,OAAO,IAAI,CAAC;QAC5D,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC7B,cAAc,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;YAAC,OAAO,IAAI,CAAC;QAClF,CAAC;QACD,cAAc,CAAC,IAAI,KAAK,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;QAClF,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACzG,cAAc,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,KAAK,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,KAAK,MAAM,CAAC,SAAS,IAAI,SAAS,KAAK,IAAI,CAAC,CAAC;QAC7G,cAAc,CAAC,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,CAAC;QACpC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACpB,IAAI,CAAC;YACH,IAAI,KAAK,EAAE,CAAC;gBACV,MAAM,MAAM,GAAG,MAAM,CAAC,wBAAwB,CAAC,IAAI,EAAE,QAAQ,CAAC,EAAE,KAAK,CAAC;gBACtE,cAAc,CAAC,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,MAAM,IAAI,CAAC,IAAI,MAAM,IAAI,IAAI,IAAI,IAAI,CAAC,MAAM,KAAK,MAAM,GAAG,CAAC,CAAC,CAAC;gBAC5G,MAAM,MAAM,GAAc,EAAE,CAAC;gBAC7B,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;oBAC5C,MAAM,UAAU,GAAG,MAAM,CAAC,wBAAwB,CAAC,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;oBACxE,cAAc,CAAC,UAAU,EAAE,UAAU,IAAI,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC;oBAC7E,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC;gBACjD,CAAC;gBACD,OAAO,MAAM,CAAC;YAChB,CAAC;YACD,MAAM,MAAM,GAA4B,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YAC5D,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;gBACvB,cAAc,CAAC,OAAO,GAAG,KAAK,QAAQ,CAAC,CAAC;gBAAC,OAAO,CAAC,GAAG,CAAC,CAAC;gBACtD,MAAM,UAAU,GAAG,MAAM,CAAC,wBAAwB,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;gBAC9D,cAAc,CAAC,UAAU,EAAE,UAAU,IAAI,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC;gBAC7E,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,KAAK,GAAG,CAAC,CAAC,CAAC;YAClD,CAAC;YACD,OAAO,MAAM,CAAC;QAChB,CAAC;gBAAS,CAAC;YAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAAC,CAAC;IACvC,CAAC,CAAC;IACF,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IAC9B,cAAc,CAAC,OAAO,CAAC,MAAM,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,IAAI,SAAS,CAAC,CAAC;IAC7E,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,aAAa,GAAG,CAC3B,KAAc,EAAE,IAAc,EAAE,eAAyB,EAAE,EAClC,EAAE;IAC3B,cAAc,CAAC,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;IACrF,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAClC,6EAA6E;IAC7E,+EAA+E;IAC/E,kBAAkB;IAClB,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;WACtD,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAC5E,OAAO,KAAgC,CAAC;AAC1C,CAAC,CAAC;AACF,MAAM,CAAC,MAAM,WAAW,GAAG,CAAI,KAAc,EAAE,OAAe,EAAE,IAA0B,EAAO,EAAE;IACjG,cAAc,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,IAAI,OAAO,CAAC,CAAC;IAAC,OAAO,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;AAC1F,CAAC,CAAC;AACF,MAAM,CAAC,MAAM,aAAa,GAAG,CAAI,MAAW,EAAE,GAAwB,EAAO,EAAE;IAC7E,cAAc,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,KAAK,CAAC,IAAI,GAAG,CAAC,MAAM,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAAC,OAAO,MAAM,CAAC;AACpH,CAAC,CAAC;AACF,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,KAAc,EAAU,EAAE;IAClD,cAAc,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,qCAAqC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IAAC,OAAO,KAAK,CAAC;AAC/G,CAAC,CAAC;AACF,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,KAAc,EAAE,OAAO,GAAG,MAAM,CAAC,gBAAgB,GAAG,CAAC,EAAU,EAAE;IAC9F,cAAc,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,IAAI,KAAK,IAAI,OAAO,CAAC,CAAC;IAAC,OAAO,KAAK,CAAC;AAC1H,CAAC,CAAC;AACF,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,KAAc,EAAiB,EAAE;IAC7D,cAAc,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,uBAAuB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IAAC,OAAO,KAAsB,CAAC;AAClH,CAAC,CAAC;AACF,+FAA+F;AAC/F,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,KAAc,EAAU,EAAE;IACzD,cAAc,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,iBAAiB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IAAC,OAAO,KAAK,CAAC;AAC3F,CAAC,CAAC;AACF,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,KAAc,EAAwB,EAAE;IACxE,MAAM,IAAI,GAAG,aAAa,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;IAC3D,cAAc,CAAC,IAAI,CAAC,IAAI,KAAK,SAAS,IAAI,IAAI,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC;IAClE,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,EAAE,EAAE,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;AACnF,CAAC,CAAC;AACF,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,IAA6B,EAA8B,EAAE,CAAC,CAAC;IAC1F,UAAU,EAAE,iBAAiB,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,gBAAgB,EAAE,SAAS,CAAC,IAAI,CAAC,gBAAgB,CAAC;CACnI,CAAC,CAAC;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,IAAgC,EAAE,KAAiC,EAAW,EAAE,CAC/G,YAAY,CAAC,IAAI,CAAC,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC,IAAI,IAAI,CAAC,MAAM,KAAK,KAAK,CAAC,MAAM,IAAI,IAAI,CAAC,gBAAgB,KAAK,KAAK,CAAC,gBAAgB,CAAC;AACtI,MAAM,CAAC,MAAM,wBAAwB,GAAG,OAAO,CAAC;AAChD,gHAAgH;AAChH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,KAAc,EAA4B,EAAE;IAC3E,MAAM,IAAI,GAAG,aAAa,CAAC,KAAK,EAAE,CAAC,UAAU,EAAE,WAAW,EAAE,WAAW,CAAC,CAAC,CAAC;IAC1E,MAAM,MAAM,GAAG,EAAE,QAAQ,EAAE,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,SAAS,EAAE,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,SAAS,EAAE,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC;IACjJ,cAAc,CAAC,MAAM,CAAC,SAAS,IAAI,MAAM,CAAC,QAAQ,IAAI,MAAM,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS;WACpF,MAAM,CAAC,SAAS,GAAG,MAAM,CAAC,QAAQ,IAAI,wBAAwB,CAAC,CAAC;IACrE,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AACF,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,KAAc,EAAgC,EAAE;IAC/E,MAAM,IAAI,GAAG,aAAa,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,CAAC,CAAC,CAAC;IAClE,OAAO,EAAE,EAAE,EAAE,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,UAAU,EAAE,cAAc,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;AACrH,CAAC,CAAC;AACF,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,KAAmC,EAAgC,EAAE,CACtG,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,UAAU,EAAE,KAAK,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;AACzE,0GAA0G;AAC1G,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,OAAuC,EAAE,UAAuC,EAAW,EAAE,CACnI,gBAAgB,CAAC,OAAO,EAAE,UAAU,CAAC,IAAI,YAAY,CAAC,OAAO,CAAC,UAAU,EAAE,kBAAkB,CAAC,UAAU,CAAC,CAAC,CAAC;AAC5G;;;GAGG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CACvC,UAAuC,EAAE,OAA8C,EAC7D,EAAE;IAC5B,IAAI,OAAO,KAAK,IAAI;QAAE,OAAO,UAAU,CAAC,GAAG,CAAC;IAC5C,cAAc,CAAC,uBAAuB,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC;IAC7D,OAAO,OAAO,CAAC,GAAG,CAAC;AACrB,CAAC,CAAC;AACF,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,IAA6B,EAAE,EAAE;IAC/D,MAAM,EAAE,GAAG,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,UAAU,GAAG,cAAc,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAC5E,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,gBAAgB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IACjF,cAAc,CAAC,UAAU,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,KAAK,IAAI,CAAC,CAAC,CAAC,QAAQ,EAAE,EAAE,KAAK,EAAE,IAAI,QAAQ,CAAC,UAAU,KAAK,UAAU,GAAG,CAAC,CAAC,CAAC;IACrH,OAAO,EAAE,EAAE,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC;AACtC,CAAC,CAAC;AACF,MAAM,CAAC,MAAM,WAAW,GAAG,KAAK,EAAE,MAAc,EAAE,KAAgC,EAA0B,EAAE;IAC5G,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,GAAG,KAAK,CAAC;IAC9C,OAAO,UAAU,MAAM,4BAA4B,CAAC,gBAAgB,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,EAAE,WAAW,CAAC,EAAE,CAAC;AAC5G,CAAC,CAAC;AACF,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,KAAc,EAAU,EAAE;IACpD,cAAc,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC;IAChE,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAC/B,cAAc,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,yBAAyB,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC;IACvH,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AACF,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,KAAa,EAAU,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,CAAC,GAAG,GAAG,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;AAChI,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,KAAa,EAAoB,EAAE;IACrE,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,KAAK,GAAG,iBAAiB,CAAC,OAAO,CAAC,CAAC;IAC7E,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AACvD,CAAC,CAAC;AACF,uEAAuE;AACvE,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,KAAc,EAAU,EAAE;IACtD,cAAc,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC;IAChE,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAC/B,cAAc,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,8BAA8B,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACpF,cAAc,CAAC,iBAAiB,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;IAC9F,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AACF,6DAA6D;AAC7D,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,KAAc,EAAU,EAAE;IAC7D,MAAM,MAAM,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC;IACpC,cAAc,CAAC,CAAC,YAAY,EAAE,eAAe,EAAE,gBAAgB,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;IAChH,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AACF,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,KAAa,EAAE,KAAa,EAAW,EAAE;IACvE,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,mBAAmB,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,mBAAmB,CAAC,KAAK,CAAC,CAAC;IAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC1G,CAAC,CAAC;AACF,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,IAAY,EAAE,KAAa,EAAW,EAAE;IACtE,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,mBAAmB,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,mBAAmB,CAAC,KAAK,CAAC,CAAC;IAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACzG,CAAC,CAAC"}

package/dist_ts/private/producercontract.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The runtime producer records read decoded input with the network family's strict JSON readers,
+ * and every producer snapshot runs inside `producerSafe`: whichever rule refused, a caller sees
+ * this one rejection and learns nothing about which field failed.
+ */
+export declare const failProducer: () => never;
+export declare const producerSafe: <T>(operation: () => T) => T;
+/** Membership in a closed union whose members are listed once, as the array the union is derived from. */
+export declare const isOneOf: <T extends string>(members: readonly T[], value: unknown) => value is T;
+/** The tag of a captured tagged record, read before the record's exact keys are known. */
+export declare const variantOf: (value: unknown, tag: string) => unknown;

package/dist_ts/private/producercontract.js

@@ -0,0 +1,21 @@
+import { requireNetwork } from './networkcontract.js';
+/**
+ * The runtime producer records read decoded input with the network family's strict JSON readers,
+ * and every producer snapshot runs inside `producerSafe`: whichever rule refused, a caller sees
+ * this one rejection and learns nothing about which field failed.
+ */
+export const failProducer = () => { throw new Error('Runtime producer contract rejected.'); };
+export const producerSafe = (operation) => { try {
+    return operation();
+}
+catch {
+    return failProducer();
+} };
+/** Membership in a closed union whose members are listed once, as the array the union is derived from. */
+export const isOneOf = (members, value) => members.includes(value);
+/** The tag of a captured tagged record, read before the record's exact keys are known. */
+export const variantOf = (value, tag) => {
+    requireNetwork(value !== null && typeof value === 'object' && !Array.isArray(value));
+    return value[tag];
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvZHVjZXJjb250cmFjdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL3ByaXZhdGUvcHJvZHVjZXJjb250cmFjdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFFdEQ7Ozs7R0FJRztBQUNILE1BQU0sQ0FBQyxNQUFNLFlBQVksR0FBRyxHQUFVLEVBQUUsR0FBRyxNQUFNLElBQUksS0FBSyxDQUFDLHFDQUFxQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7QUFDckcsTUFBTSxDQUFDLE1BQU0sWUFBWSxHQUFHLENBQUksU0FBa0IsRUFBSyxFQUFFLEdBQUcsSUFBSSxDQUFDO0lBQUMsT0FBTyxTQUFTLEVBQUUsQ0FBQztBQUFDLENBQUM7QUFBQyxNQUFNLENBQUM7SUFBQyxPQUFPLFlBQVksRUFBRSxDQUFDO0FBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztBQUUzSCwwR0FBMEc7QUFDMUcsTUFBTSxDQUFDLE1BQU0sT0FBTyxHQUFHLENBQW1CLE9BQXFCLEVBQUUsS0FBYyxFQUFjLEVBQUUsQ0FDNUYsT0FBOEIsQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFDLENBQUM7QUFFbEQsMEZBQTBGO0FBQzFGLE1BQU0sQ0FBQyxNQUFNLFNBQVMsR0FBRyxDQUFDLEtBQWMsRUFBRSxHQUFXLEVBQVcsRUFBRTtJQUNoRSxjQUFjLENBQUMsS0FBSyxLQUFLLElBQUksSUFBSSxPQUFPLEtBQUssS0FBSyxRQUFRLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7SUFDckYsT0FBUSxLQUFpQyxDQUFDLEdBQUcsQ0FBQyxDQUFDO0FBQ2pELENBQUMsQ0FBQyJ9

package/dist_ts/private/runtimepolicy.d.ts

@@ -0,0 +1,31 @@
+import type { IRuntimeConfigLogPolicyV1 } from '../data/runtimeconfig.js';
+/**
+ * The execution policy a runtime config seals and a service runtime profile states ahead of it.
+ * Both validators apply these timing, HTTP request, CPU, memory, identity and log rules. Only the
+ * service's target ports decide whether a readiness target exists, which a profile cannot know.
+ *
+ * Every check here reads captured plain data only, the output of `snapshotBoundedJson` or
+ * `captureNetwork`: on live input a getter could pass a check and then hand the caller another value.
+ */
+export declare const runtimePolicyLimits: Readonly<{
+    readonly minimumMemoryBytes: number;
+    readonly maximumMemoryBytes: number;
+    readonly maximumCpuMillis: 1000000;
+    readonly maximumIdentityNumber: number;
+    readonly maximumReadinessDurationMs: 3600000;
+    readonly maximumLogRetentionMs: 31536000000;
+}>;
+export type TRuntimePolicyFailure = (messageArg: string) => never;
+export declare const isBoundedInteger: (valueArg: unknown, minimumArg: number, maximumArg: number) => valueArg is number;
+export declare const isRuntimePortName: (valueArg: unknown) => valueArg is string;
+export declare const isExactRecord: (valueArg: unknown, keysArg: readonly string[]) => valueArg is Record<string, unknown>;
+/** null explicitly requests no CPU quota; zero is never a quota. */
+export declare const isRuntimeCpuMillis: (valueArg: unknown) => valueArg is number | null;
+export declare const isRuntimeMemoryBytes: (valueArg: unknown) => valueArg is number;
+export declare const isRuntimeIdentityNumber: (valueArg: unknown) => valueArg is number;
+export declare const isRuntimeLogPolicy: (valueArg: unknown) => valueArg is IRuntimeConfigLogPolicyV1;
+/**
+ * Readiness policy. `selectsTcpTargetArg` decides whether a probe's named target and port exist:
+ * a config answers from its own target ports, a profile ahead of any config cannot know them.
+ */
+export declare const assertRuntimeReadiness: (valueArg: unknown, selectsTcpTargetArg: (targetPortArg: string, portArg: number) => boolean, failArg: TRuntimePolicyFailure) => void;

package/dist_ts/private/runtimepolicy.js

@@ -0,0 +1,90 @@
+/**
+ * The execution policy a runtime config seals and a service runtime profile states ahead of it.
+ * Both validators apply these timing, HTTP request, CPU, memory, identity and log rules. Only the
+ * service's target ports decide whether a readiness target exists, which a profile cannot know.
+ *
+ * Every check here reads captured plain data only, the output of `snapshotBoundedJson` or
+ * `captureNetwork`: on live input a getter could pass a check and then hand the caller another value.
+ */
+export const runtimePolicyLimits = Object.freeze({
+    minimumMemoryBytes: 16 * 1024 * 1024,
+    maximumMemoryBytes: 2 ** 50,
+    maximumCpuMillis: 1_000_000,
+    maximumIdentityNumber: 2 ** 31 - 1,
+    maximumReadinessDurationMs: 3_600_000,
+    maximumLogRetentionMs: 31_536_000_000,
+});
+export const isBoundedInteger = (valueArg, minimumArg, maximumArg) => typeof valueArg === 'number' && Number.isSafeInteger(valueArg) && !Object.is(valueArg, -0)
+    && valueArg >= minimumArg && valueArg <= maximumArg;
+export const isRuntimePortName = (valueArg) => typeof valueArg === 'string' && /^[a-z0-9][a-z0-9_.-]{0,62}$/.test(valueArg);
+export const isExactRecord = (valueArg, keysArg) => {
+    if (!valueArg || typeof valueArg !== 'object' || Array.isArray(valueArg))
+        return false;
+    const keys = Object.keys(valueArg);
+    return keys.length === keysArg.length && keys.every((keyArg) => keysArg.includes(keyArg));
+};
+/** null explicitly requests no CPU quota; zero is never a quota. */
+export const isRuntimeCpuMillis = (valueArg) => valueArg === null || isBoundedInteger(valueArg, 1, runtimePolicyLimits.maximumCpuMillis);
+export const isRuntimeMemoryBytes = (valueArg) => isBoundedInteger(valueArg, runtimePolicyLimits.minimumMemoryBytes, runtimePolicyLimits.maximumMemoryBytes);
+export const isRuntimeIdentityNumber = (valueArg) => isBoundedInteger(valueArg, 0, runtimePolicyLimits.maximumIdentityNumber);
+export const isRuntimeLogPolicy = (valueArg) => isExactRecord(valueArg, ['maximumLineBytes', 'maximumBufferedBytes', 'retentionMs'])
+    && isBoundedInteger(valueArg.maximumLineBytes, 1, 1_048_576)
+    && isBoundedInteger(valueArg.maximumBufferedBytes, 1, 67_108_864)
+    && valueArg.maximumBufferedBytes >= valueArg.maximumLineBytes
+    && isBoundedInteger(valueArg.retentionMs, 1, runtimePolicyLimits.maximumLogRetentionMs);
+const timingKeys = ['initialDelayMs', 'startupGraceMs', 'intervalMs', 'timeoutMs',
+    'successThreshold', 'failureThreshold'];
+/**
+ * Readiness policy. `selectsTcpTargetArg` decides whether a probe's named target and port exist:
+ * a config answers from its own target ports, a profile ahead of any config cannot know them.
+ */
+export const assertRuntimeReadiness = (valueArg, selectsTcpTargetArg, failArg) => {
+    if (!valueArg || typeof valueArg !== 'object')
+        failArg('runtime config readiness is required');
+    const value = valueArg;
+    const keys = value.kind === 'process' ? ['kind', ...timingKeys]
+        : value.kind === 'tcp' ? ['kind', ...timingKeys, 'targetPort', 'port']
+            : value.kind === 'http' ? ['kind', ...timingKeys, 'targetPort', 'port',
+                'scheme', 'host', 'path', 'expectedStatusCodes', 'followRedirects'] : [];
+    const maximumDurationMs = runtimePolicyLimits.maximumReadinessDurationMs;
+    if (keys.length === 0 || !isExactRecord(value, keys)
+        || !isBoundedInteger(value.initialDelayMs, 0, maximumDurationMs)
+        || !isBoundedInteger(value.startupGraceMs, 0, maximumDurationMs)
+        || !isBoundedInteger(value.intervalMs, 100, maximumDurationMs)
+        || !isBoundedInteger(value.timeoutMs, 1, 60_000)
+        || !isBoundedInteger(value.successThreshold, 1, 100)
+        || !isBoundedInteger(value.failureThreshold, 1, 100)
+        || value.timeoutMs > value.intervalMs || value.initialDelayMs > value.startupGraceMs) {
+        failArg('runtime config readiness must use explicit bounded timing and exact schema');
+    }
+    if (value.kind === 'process')
+        return;
+    if (!isRuntimePortName(value.targetPort) || !isBoundedInteger(value.port, 1, 65535)
+        || !selectsTcpTargetArg(value.targetPort, value.port)) {
+        failArg('runtime config readiness must select a declared TCP target and port');
+    }
+    if (value.kind === 'tcp')
+        return;
+    if ((value.scheme !== 'http' && value.scheme !== 'https') || value.followRedirects !== false
+        || typeof value.host !== 'string' || value.host.length > 253
+        || !/^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/.test(value.host)
+        || typeof value.path !== 'string' || value.path.length > 4096
+        || !value.path.startsWith('/') || value.path.startsWith('//')
+        || /[^\x21-\x7e]|[\\#]/.test(value.path)
+        || /%(?![0-9A-F]{2})/.test(value.path)
+        || !Array.isArray(value.expectedStatusCodes) || value.expectedStatusCodes.length === 0
+        || value.expectedStatusCodes.length > 32) {
+        failArg('runtime config HTTP readiness must use an exact bounded request policy');
+    }
+    const parsed = new URL(value.path, 'http://runtime.invalid');
+    if (`${parsed.pathname}${parsed.search}` !== value.path)
+        failArg('runtime config HTTP path must be canonical');
+    let previousCode = 0;
+    for (const code of value.expectedStatusCodes) {
+        if (!isBoundedInteger(code, 200, 599) || code <= previousCode) {
+            failArg('runtime config HTTP status expectations must be sorted unique final codes');
+        }
+        previousCode = code;
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVudGltZXBvbGljeS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL3ByaXZhdGUvcnVudGltZXBvbGljeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQTs7Ozs7OztHQU9HO0FBQ0gsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBQUcsTUFBTSxDQUFDLE1BQU0sQ0FBQztJQUMvQyxrQkFBa0IsRUFBRSxFQUFFLEdBQUcsSUFBSSxHQUFHLElBQUk7SUFDcEMsa0JBQWtCLEVBQUUsQ0FBQyxJQUFJLEVBQUU7SUFDM0IsZ0JBQWdCLEVBQUUsU0FBUztJQUMzQixxQkFBcUIsRUFBRSxDQUFDLElBQUksRUFBRSxHQUFHLENBQUM7SUFDbEMsMEJBQTBCLEVBQUUsU0FBUztJQUNyQyxxQkFBcUIsRUFBRSxjQUFjO0NBQzdCLENBQUMsQ0FBQztBQUlaLE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFHLENBQUMsUUFBaUIsRUFBRSxVQUFrQixFQUFFLFVBQWtCLEVBQXNCLEVBQUUsQ0FDaEgsT0FBTyxRQUFRLEtBQUssUUFBUSxJQUFJLE1BQU0sQ0FBQyxhQUFhLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUMsQ0FBQztPQUN2RixRQUFRLElBQUksVUFBVSxJQUFJLFFBQVEsSUFBSSxVQUFVLENBQUM7QUFDdEQsTUFBTSxDQUFDLE1BQU0saUJBQWlCLEdBQUcsQ0FBQyxRQUFpQixFQUFzQixFQUFFLENBQ3pFLE9BQU8sUUFBUSxLQUFLLFFBQVEsSUFBSSw2QkFBNkIsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUM7QUFDL0UsTUFBTSxDQUFDLE1BQU0sYUFBYSxHQUFHLENBQzNCLFFBQWlCLEVBQUUsT0FBMEIsRUFDUixFQUFFO0lBQ3ZDLElBQUksQ0FBQyxRQUFRLElBQUksT0FBTyxRQUFRLEtBQUssUUFBUSxJQUFJLEtBQUssQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDO1FBQUUsT0FBTyxLQUFLLENBQUM7SUFDdkYsTUFBTSxJQUFJLEdBQUcsTUFBTSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQztJQUNuQyxPQUFPLElBQUksQ0FBQyxNQUFNLEtBQUssT0FBTyxDQUFDLE1BQU0sSUFBSSxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsTUFBTSxFQUFFLEVBQUUsQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUM7QUFDNUYsQ0FBQyxDQUFDO0FBRUYsb0VBQW9FO0FBQ3BFLE1BQU0sQ0FBQyxNQUFNLGtCQUFrQixHQUFHLENBQUMsUUFBaUIsRUFBNkIsRUFBRSxDQUNqRixRQUFRLEtBQUssSUFBSSxJQUFJLGdCQUFnQixDQUFDLFFBQVEsRUFBRSxDQUFDLEVBQUUsbUJBQW1CLENBQUMsZ0JBQWdCLENBQUMsQ0FBQztBQUMzRixNQUFNLENBQUMsTUFBTSxvQkFBb0IsR0FBRyxDQUFDLFFBQWlCLEVBQXNCLEVBQUUsQ0FDNUUsZ0JBQWdCLENBQUMsUUFBUSxFQUFFLG1CQUFtQixDQUFDLGtCQUFrQixFQUFFLG1CQUFtQixDQUFDLGtCQUFrQixDQUFDLENBQUM7QUFDN0csTUFBTSxDQUFDLE1BQU0sdUJBQXVCLEdBQUcsQ0FBQyxRQUFpQixFQUFzQixFQUFFLENBQy9FLGdCQUFnQixDQUFDLFFBQVEsRUFBRSxDQUFDLEVBQUUsbUJBQW1CLENBQUMscUJBQXFCLENBQUMsQ0FBQztBQUUzRSxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxDQUFDLFFBQWlCLEVBQXlDLEVBQUUsQ0FDN0YsYUFBYSxDQUFDLFFBQVEsRUFBRSxDQUFDLGtCQUFrQixFQUFFLHNCQUFzQixFQUFFLGFBQWEsQ0FBQyxDQUFDO09BQ2pGLGdCQUFnQixDQUFDLFFBQVEsQ0FBQyxnQkFBZ0IsRUFBRSxDQUFDLEVBQUUsU0FBUyxDQUFDO09BQ3pELGdCQUFnQixDQUFDLFFBQVEsQ0FBQyxvQkFBb0IsRUFBRSxDQUFDLEVBQUUsVUFBVSxDQUFDO09BQzlELFFBQVEsQ0FBQyxvQkFBb0IsSUFBSSxRQUFRLENBQUMsZ0JBQWdCO09BQzFELGdCQUFnQixDQUFDLFFBQVEsQ0FBQyxXQUFXLEVBQUUsQ0FBQyxFQUFFLG1CQUFtQixDQUFDLHFCQUFxQixDQUFDLENBQUM7QUFFMUYsTUFBTSxVQUFVLEdBQUcsQ0FBQyxnQkFBZ0IsRUFBRSxnQkFBZ0IsRUFBRSxZQUFZLEVBQUUsV0FBVztJQUMvRSxrQkFBa0IsRUFBRSxrQkFBa0IsQ0FBVSxDQUFDO0FBRW5EOzs7R0FHRztBQUNILE1BQU0sQ0FBQyxNQUFNLHNCQUFzQixHQUFHLENBQ3BDLFFBQWlCLEVBQ2pCLG1CQUF3RSxFQUN4RSxPQUE4QixFQUN4QixFQUFFO0lBQ1IsSUFBSSxDQUFDLFFBQVEsSUFBSSxPQUFPLFFBQVEsS0FBSyxRQUFRO1FBQUUsT0FBTyxDQUFDLHNDQUFzQyxDQUFDLENBQUM7SUFDL0YsTUFBTSxLQUFLLEdBQUcsUUFBbUMsQ0FBQztJQUNsRCxNQUFNLElBQUksR0FBRyxLQUFLLENBQUMsSUFBSSxLQUFLLFNBQVMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxNQUFNLEVBQUUsR0FBRyxVQUFVLENBQUM7UUFDN0QsQ0FBQyxDQUFDLEtBQUssQ0FBQyxJQUFJLEtBQUssS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLE1BQU0sRUFBRSxHQUFHLFVBQVUsRUFBRSxZQUFZLEVBQUUsTUFBTSxDQUFDO1lBQ3BFLENBQUMsQ0FBQyxLQUFLLENBQUMsSUFBSSxLQUFLLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxNQUFNLEVBQUUsR0FBRyxVQUFVLEVBQUUsWUFBWSxFQUFFLE1BQU07Z0JBQ3BFLFFBQVEsRUFBRSxNQUFNLEVBQUUsTUFBTSxFQUFFLHFCQUFxQixFQUFFLGlCQUFpQixDQUFDLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQztJQUMvRSxNQUFNLGlCQUFpQixHQUFHLG1CQUFtQixDQUFDLDBCQUEwQixDQUFDO0lBQ3pFLElBQUksSUFBSSxDQUFDLE1BQU0sS0FBSyxDQUFDLElBQUksQ0FBQyxhQUFhLENBQUMsS0FBSyxFQUFFLElBQUksQ0FBQztXQUMvQyxDQUFDLGdCQUFnQixDQUFDLEtBQUssQ0FBQyxjQUFjLEVBQUUsQ0FBQyxFQUFFLGlCQUFpQixDQUFDO1dBQzdELENBQUMsZ0JBQWdCLENBQUMsS0FBSyxDQUFDLGNBQWMsRUFBRSxDQUFDLEVBQUUsaUJBQWlCLENBQUM7V0FDN0QsQ0FBQyxnQkFBZ0IsQ0FBQyxLQUFLLENBQUMsVUFBVSxFQUFFLEdBQUcsRUFBRSxpQkFBaUIsQ0FBQztXQUMzRCxDQUFDLGdCQUFnQixDQUFDLEtBQUssQ0FBQyxTQUFTLEVBQUUsQ0FBQyxFQUFFLE1BQU0sQ0FBQztXQUM3QyxDQUFDLGdCQUFnQixDQUFDLEtBQUssQ0FBQyxnQkFBZ0IsRUFBRSxDQUFDLEVBQUUsR0FBRyxDQUFDO1dBQ2pELENBQUMsZ0JBQWdCLENBQUMsS0FBSyxDQUFDLGdCQUFnQixFQUFFLENBQUMsRUFBRSxHQUFHLENBQUM7V0FDakQsS0FBSyxDQUFDLFNBQVMsR0FBRyxLQUFLLENBQUMsVUFBVSxJQUFJLEtBQUssQ0FBQyxjQUFjLEdBQUcsS0FBSyxDQUFDLGNBQWMsRUFBRSxDQUFDO1FBQ3ZGLE9BQU8sQ0FBQyw0RUFBNEUsQ0FBQyxDQUFDO0lBQ3hGLENBQUM7SUFDRCxJQUFJLEtBQUssQ0FBQyxJQUFJLEtBQUssU0FBUztRQUFFLE9BQU87SUFDckMsSUFBSSxDQUFDLGlCQUFpQixDQUFDLEtBQUssQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLGdCQUFnQixDQUFDLEtBQUssQ0FBQyxJQUFJLEVBQUUsQ0FBQyxFQUFFLEtBQUssQ0FBQztXQUM5RSxDQUFDLG1CQUFtQixDQUFDLEtBQUssQ0FBQyxVQUFVLEVBQUUsS0FBSyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUM7UUFDeEQsT0FBTyxDQUFDLHFFQUFxRSxDQUFDLENBQUM7SUFDakYsQ0FBQztJQUNELElBQUksS0FBSyxDQUFDLElBQUksS0FBSyxLQUFLO1FBQUUsT0FBTztJQUNqQyxJQUFJLENBQUMsS0FBSyxDQUFDLE1BQU0sS0FBSyxNQUFNLElBQUksS0FBSyxDQUFDLE1BQU0sS0FBSyxPQUFPLENBQUMsSUFBSSxLQUFLLENBQUMsZUFBZSxLQUFLLEtBQUs7V0FDdkYsT0FBTyxLQUFLLENBQUMsSUFBSSxLQUFLLFFBQVEsSUFBSSxLQUFLLENBQUMsSUFBSSxDQUFDLE1BQU0sR0FBRyxHQUFHO1dBQ3pELENBQUMsdUZBQXVGLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUM7V0FDekcsT0FBTyxLQUFLLENBQUMsSUFBSSxLQUFLLFFBQVEsSUFBSSxLQUFLLENBQUMsSUFBSSxDQUFDLE1BQU0sR0FBRyxJQUFJO1dBQzFELENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUFDLElBQUksS0FBSyxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDO1dBQzFELG9CQUFvQixDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDO1dBQ3JDLGtCQUFrQixDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDO1dBQ25DLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsbUJBQW1CLENBQUMsSUFBSSxLQUFLLENBQUMsbUJBQW1CLENBQUMsTUFBTSxLQUFLLENBQUM7V0FDbkYsS0FBSyxDQUFDLG1CQUFtQixDQUFDLE1BQU0sR0FBRyxFQUFFLEVBQUUsQ0FBQztRQUMzQyxPQUFPLENBQUMsd0VBQXdFLENBQUMsQ0FBQztJQUNwRixDQUFDO0lBQ0QsTUFBTSxNQUFNLEdBQUcsSUFBSSxHQUFHLENBQUMsS0FBSyxDQUFDLElBQUksRUFBRSx3QkFBd0IsQ0FBQyxDQUFDO0lBQzdELElBQUksR0FBRyxNQUFNLENBQUMsUUFBUSxHQUFHLE1BQU0sQ0FBQyxNQUFNLEVBQUUsS0FBSyxLQUFLLENBQUMsSUFBSTtRQUFFLE9BQU8sQ0FBQyw0Q0FBNEMsQ0FBQyxDQUFDO0lBQy9HLElBQUksWUFBWSxHQUFHLENBQUMsQ0FBQztJQUNyQixLQUFLLE1BQU0sSUFBSSxJQUFJLEtBQUssQ0FBQyxtQkFBbUIsRUFBRSxDQUFDO1FBQzdDLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxJQUFJLEVBQUUsR0FBRyxFQUFFLEdBQUcsQ0FBQyxJQUFJLElBQUksSUFBSSxZQUFZLEVBQUUsQ0FBQztZQUM5RCxPQUFPLENBQUMsMkVBQTJFLENBQUMsQ0FBQztRQUN2RixDQUFDO1FBQ0QsWUFBWSxHQUFHLElBQUksQ0FBQztJQUN0QixDQUFDO0FBQ0gsQ0FBQyxDQUFDIn0=