onveloz 0.0.0-beta.46 → 0.0.0-beta.47

package/dist/{deploy-stream-kdbyBK5b.mjs → deploy-stream-Crwv3sYL.mjs}

@@ -1,5 +1,5 @@
 import { C as endGroup, D as log, E as isMcpMode, O as startGroup, k as success, n as loadConfig, r as requireAuth, w as info } from "./config-DaQHTlyP.mjs";
-import { a as findStrippedConfigKeys, c as resolveConfigForEnv, d as suggestConfigKeyFix, s as parseVelozConfig } from "./veloz-config-iN8SFxrR.mjs";
+import { a as findStrippedConfigKeys, c as resolveConfigForEnv, d as suggestConfigKeyFix, s as parseVelozConfig } from "./veloz-config-59H2mWOA.mjs";
 import { createORPCClient } from "@orpc/client";
 import { RPCLink } from "@orpc/client/fetch";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
@@ -193,7 +193,7 @@ function getGitBranch() {
 
 //#endregion
 //#region src/lib/client.ts
-const CLI_VERSION = "0.0.0-beta.46";
+const CLI_VERSION = "0.0.0-beta.47";
 const USER_AGENT = `veloz-cli/${CLI_VERSION}`;
 /**
 * Client source — "cli" by default; the init wizard sets this to "cli-wizard"
@@ -257,19 +257,20 @@ async function getClient() {
 
 //#endregion
 //#region src/lib/deploy-constants.ts
+const labels = {
+	QUEUED: "Na fila",
+	BUILDING: "Compilando",
+	BUILD_FAILED: "Falha na compilação",
+	DEPLOYING: "Realizando deploy",
+	WAITING_ON_PROVIDER: "Provisionando",
+	LIVE: "Ativo",
+	FAILED: "Falhou",
+	CANCELLED: "Cancelado",
+	SKIPPED: "Ignorado",
+	SUPERSEDED: "Substituído"
+};
 /** Portuguese label per deployment status, keyed by the status string the server streams. */
-const statusLabels = new Map([
-	["QUEUED", "Na fila"],
-	["BUILDING", "Compilando"],
-	["BUILD_FAILED", "Falha na compilação"],
-	["DEPLOYING", "Realizando deploy"],
-	["WAITING_ON_PROVIDER", "Provisionando"],
-	["LIVE", "Ativo"],
-	["FAILED", "Falhou"],
-	["CANCELLED", "Cancelado"],
-	["SKIPPED", "Ignorado"],
-	["SUPERSEDED", "Substituído"]
-]);
+const statusLabels = new Map(Object.entries(labels));
 function makeStatusIcons() {
 	if (!process.stdout.isTTY) return new Map([
 		["QUEUED", "○"],
@@ -831,7 +832,7 @@ async function streamDeploymentLogs(deploymentId, serviceId, serviceName, option
 		isVerbose,
 		useTui: options.useTui
 	})) {
-		const { renderDeployTUI } = await import("./deploy-tui-DsIMdS4Y.mjs");
+		const { renderDeployTUI } = await import("./deploy-tui-BY_5U4Al.mjs");
 		return renderDeployTUI(deploymentId, serviceId, serviceName);
 	}
 	const allLogLines = [];

package/dist/{deploy-tui-DsIMdS4Y.mjs → deploy-tui-BY_5U4Al.mjs}

@@ -1,6 +1,6 @@
-import { f as statusLabels, h as getClient, i as parseBuildLine, n as fetchDeployUrls, r as isHiddenMessage, s as getFailureHints, t as cleanDisplayLine, u as TERMINAL_STATUSES } from "./deploy-stream-kdbyBK5b.mjs";
+import { f as statusLabels, h as getClient, i as parseBuildLine, n as fetchDeployUrls, r as isHiddenMessage, s as getFailureHints, t as cleanDisplayLine, u as TERMINAL_STATUSES } from "./deploy-stream-Crwv3sYL.mjs";
 import { k as success, w as info } from "./config-DaQHTlyP.mjs";
-import "./veloz-config-iN8SFxrR.mjs";
+import "./veloz-config-59H2mWOA.mjs";
 import chalk from "chalk";
 import { useEffect, useRef, useState } from "react";
 import { Box, Static, Text, render, useApp } from "ink";

package/dist/edge-dev-PhZX9ZbE.mjs

@@ -0,0 +1,5 @@
+import "./Schema-Cg34DK63.mjs";
+import "./veloz-config-59H2mWOA.mjs";
+import { i as startEdgeDev, n as edgeDevOptionsSchema, r as runEdgeDev, t as EdgeDevError } from "./edge-dev-Wrtj1z2W.mjs";
+
+export { runEdgeDev };

package/dist/{edge-dev-ATMqwxjd.mjs → edge-dev-Wrtj1z2W.mjs}

@@ -1,5 +1,5 @@
 import { A as isGreaterThanOrEqualTo, B as withDecodingDefaultKey, C as decodeUnknownPromise, Ct as getOrElse, D as isBetween, F as makeFilter, H as acquireRelease, I as optional, K as callback, L as optionalKey, M as isLengthBetween, Mt as isObjectOrArray, N as isMaxLength, Nt as flow, O as isFinite, P as isPattern, Q as mapError, R as suspend, S as decodeUnknownOption, St as isFailure, T as fromJsonString, Tt as getOrThrowWith, X as gen, Y as fn, Z as ignore, _ as Union, a as Literals, at as raceFirst, c as NullishOr, d as String, f as Struct, ft as sync, g as UndefinedOr, i as Literal, j as isInt, jt as hasProperty, k as isGreaterThan, l as Number$1, lt as scoped, m as TaggedStruct, mt as try_, n as Boolean, o as NonEmptyString, ot as result, p as StructWithRest, pt as tryPromise, q as fail, r as Date$1, rt as promise, s as NullOr, st as runPromise, t as ArraySchema, u as Record, ut as succeed, v as Unknown, vt as TaggedError, w as decodeUnknownSync, x as decodeUnknownEffect, z as toTaggedUnion } from "./Schema-Cg34DK63.mjs";
-import { F as nativeWorkerEntrypointSchema, I as nativeWorkerScheduleCronSchema, M as MAX_WORKER_SCHEDULED_CRON_LENGTH, N as nativeWorkerAssetsDirectorySchema, P as nativeWorkerCompatibilityDateSchema, j as MAX_WORKER_SCHEDULED_BINDINGS } from "./veloz-config-iN8SFxrR.mjs";
+import { F as nativeWorkerCompatibilityDateSchema, I as nativeWorkerEntrypointSchema, L as nativeWorkerScheduleCronSchema, M as MAX_WORKER_SCHEDULED_BINDINGS, N as MAX_WORKER_SCHEDULED_CRON_LENGTH, P as nativeWorkerAssetsDirectorySchema } from "./veloz-config-59H2mWOA.mjs";
 import { createHash } from "node:crypto";
 import { constants } from "node:fs";
 import { join, relative, resolve, sep } from "node:path";
@@ -273,6 +273,36 @@ const decodeHostRetirementRecord = flow(decodeUnknownSync(StoredRecords), (decod
 	};
 });
 const decodeRetirementEnvelope = decodeUnknownSync(strictStruct({ retirement: Unknown }));
+/**
+* Hands a completed retirement's hostname to its next owner (#2337). The
+* retirement names the removal that finished; `nextServiceId` is the service
+* whose admission is taking the name.
+*/
+const HostReleaseRequestSchema = Struct({
+	intent: HostRetirementIntentSchema,
+	nextServiceId: NonEmptyString
+});
+/** The durable tombstone of one released retirement, kept per hostname and removal. */
+const HostReleaseSchema = Struct({
+	version: Literal(1),
+	intent: HostRetirementIntentSchema,
+	expectedMapDigest: NullOr(String),
+	nextServiceId: NonEmptyString
+});
+const parseHostReleaseRequest = flow(decodeUnknownSync(HostReleaseRequestSchema.annotate({ parseOptions: { onExcessProperty: "error" } })), (request) => {
+	parseHostRetirementIntent(request.intent);
+	if (request.nextServiceId.length > 128) throw new Error("Invalid release owner");
+	return request;
+});
+const decodeHostRelease = flow(decodeUnknownSync(HostReleaseSchema.annotate({ parseOptions: { onExcessProperty: "error" } })), (release) => {
+	parseHostReleaseRequest({
+		intent: release.intent,
+		nextServiceId: release.nextServiceId
+	});
+	if (release.expectedMapDigest !== null && !SHA256_HEX.test(release.expectedMapDigest)) throw new Error("Invalid retirement map digest");
+	return release;
+});
+const decodeReleaseEnvelope = decodeUnknownSync(strictStruct({ release: Unknown }));
 
 //#endregion
 //#region ../../packages/route-authority-contract/src/authority-mirror.ts
@@ -451,7 +481,7 @@ const parseHostnameReceipt = flow(contractDecoder(strictStruct({
 	prepareDigest: parsePrepareDigest$1(envelope.prepareDigest),
 	committedMapDigest: parseCommittedMapDigest$1(envelope.committedMapDigest)
 }));
-const WorkerRedeployReceiptEnvelope = strictStruct({
+const parseWorkerRedeployReceipt = flow(contractDecoder(strictStruct({
 	contractVersion: Literal(2),
 	cellId: Unknown,
 	registryEntryDigest: Unknown,
@@ -460,8 +490,7 @@ const WorkerRedeployReceiptEnvelope = strictStruct({
 	routeFence: Unknown,
 	intentDigest: Unknown,
 	hostnames: ArraySchema(Unknown).check(isLengthBetween(1, MAX_HOSTNAMES$1))
-});
-const parseWorkerRedeployReceipt = flow(contractDecoder(WorkerRedeployReceiptEnvelope, "Workers redeploy receipt is invalid"), (envelope) => {
+}), "Workers redeploy receipt is invalid"), (envelope) => {
 	const hostnames = envelope.hostnames.map((hostname) => parseHostnameReceipt(hostname));
 	if (new Set(hostnames.map((hostname) => hostname.hostname)).size !== hostnames.length || [...hostnames].sort((left, right) => left.hostname.localeCompare(right.hostname)).some((hostname, index) => hostname !== hostnames[index])) throw new Error("Workers redeploy receipt hostnames are invalid");
 	return {
@@ -784,6 +813,9 @@ const decodeExpiringDeployment = contractDecoder(strictStruct({
 	...WorkerDeploymentTargetFields,
 	expiresAt: Number$1.check(isInt(), isGreaterThan(0))
 }), "Route authority version-map expiry is invalid");
+function assertUniqueDeploymentIds(deployments, maximum) {
+	if (deployments.length > maximum || new Set(deployments.map((deployment) => deployment.deploymentId)).size !== deployments.length) throw new Error("Route authority version map has duplicate or excessive deployments");
+}
 const PreviousDeployments = ArraySchema(Unknown).check(isMaxLength(MAX_VERSION_MAP_PREVIOUS_DEPLOYMENTS));
 const decodeVersionMapPreflight = contractDecoder(strictStruct({
 	current: Unknown,
@@ -928,17 +960,19 @@ const decodeUpstreamHostState = contractDecoder(strictStruct({
 	upstream: Unknown,
 	authProtected: optionalKey(Unknown)
 }), "Route authority upstream HostState is invalid");
-const decodeWorkersHostState = contractDecoder(strictStruct({
+const decodeVersionedWorkersHostState = contractDecoder(strictStruct({
 	...HostOwnershipFields,
 	state: Literal("live"),
+	schemaVersion: Literal(2),
 	target: Unknown,
 	authProtected: optionalKey(Unknown)
-}), "Route authority Workers HostState is invalid");
-const decodeWorkersHostTarget = contractDecoder(strictStruct({
+}), "Route authority versioned Workers HostState is invalid");
+const decodeVersionedWorkersHostTarget = contractDecoder(strictStruct({
 	kind: Literal("wfp"),
-	scriptName: Unknown,
-	outboundPolicy: Unknown
-}), "Route authority Workers HostState target is invalid");
+	current: Unknown,
+	previous: PreviousDeployments,
+	staged: optionalKey(Unknown)
+}), "Route authority versioned Workers HostState target is invalid");
 const decodeAuthProtection = contractDecoder(UndefinedOr(Literal(true)), "Route authority HostState auth protection is invalid");
 const HostStateServiceId = String.check(isLengthBetween(1, 128));
 const decodeDeploymentHostState = contractDecoder(strictStruct({
@@ -970,28 +1004,46 @@ const parseUpstreamHostState = flow(decodeUpstreamHostState, (envelope) => {
 		upstream
 	};
 });
-const parseWorkersHostState = flow(decodeWorkersHostState, (envelope) => {
-	const target = decodeWorkersHostTarget(envelope.target);
-	const scriptName = parseScriptName(target.scriptName);
-	const outboundPolicy = parseOutboundPolicy(target.outboundPolicy);
-	const workerTarget = {
-		kind: target.kind,
-		scriptName,
-		outboundPolicy
+/** A drained target keeps its expiry; the drain window is judged by the redeploy that reads it. */
+const parseRetainedDeployment = flow(decodeExpiringDeployment, ({ expiresAt, ...target }) => ({
+	...parseWorkerDeploymentTarget(target),
+	expiresAt
+}));
+const parseVersionedWorkersHostState = flow(decodeVersionedWorkersHostState, (envelope) => {
+	const record = decodeVersionedWorkersHostTarget(envelope.target);
+	const current = parseWorkerDeploymentTarget(record.current);
+	const previous = record.previous.map((target$1) => parseRetainedDeployment(target$1));
+	const staged = record.staged === void 0 ? void 0 : parseRetainedDeployment(record.staged);
+	assertUniqueDeploymentIds([
+		current,
+		...previous,
+		...staged === void 0 ? [] : [staged]
+	], MAX_VERSION_MAP_PREVIOUS_DEPLOYMENTS + 2);
+	const target = staged === void 0 ? {
+		kind: record.kind,
+		current,
+		previous
+	} : {
+		kind: record.kind,
+		current,
+		previous,
+		staged
 	};
 	return decodeAuthProtection(envelope.authProtected) === true ? {
 		state: envelope.state,
-		target: workerTarget,
+		schemaVersion: envelope.schemaVersion,
+		target,
 		authProtected: true
 	} : {
 		state: envelope.state,
-		target: workerTarget
+		schemaVersion: envelope.schemaVersion,
+		target
 	};
 });
 const parseHostState = flow(decodeHostStateRecord, (record) => {
 	const migrationOperationId = record.migrationOperationId === void 0 ? void 0 : parseMigrationOperationId(record.migrationOperationId);
 	if (record.state === "live" && "upstream" in record) return withMigrationOwner(parseUpstreamHostState(record), migrationOperationId);
-	if (record.state === "live" && "target" in record) return withMigrationOwner(parseWorkersHostState(record), migrationOperationId);
+	if (record.state === "live" && "schemaVersion" in record) return withMigrationOwner(parseVersionedWorkersHostState(record), migrationOperationId);
 	if (record.state === "building" || record.state === "build_failed") {
 		const { state, serviceId, deploymentId } = decodeDeploymentHostState(record);
 		return withMigrationOwner({
@@ -1030,6 +1082,7 @@ const decodeRouteProjectionIntent = contractDecoder(strictStruct({
 	operationId: Unknown,
 	routeFence: Unknown,
 	zoneId: Unknown,
+	serviceId: optionalKey(Unknown),
 	hostnames: ProjectedHostnames
 }), "Route authority projection intent is invalid");
 const decodeHostnameIntent = contractDecoder(strictStruct({
@@ -1064,6 +1117,9 @@ const parseRouteProjectionIntent = flow(rejectForbiddenKeys, decodeRouteProjecti
 	if (new Set(hostnames.map((hostname) => hostname.hostname)).size !== hostnames.length) throw new Error("Route authority projection contains duplicate hostnames");
 	const sortedHostnames = [...hostnames].sort((left, right) => left.hostname.localeCompare(right.hostname));
 	if (sortedHostnames.some((hostname, index) => hostname !== hostnames[index])) throw new Error("Route authority projection hostnames must be sorted");
+	const service = decodeOptionalServiceId(envelope);
+	const [first] = sortedHostnames;
+	if (service.serviceId !== void 0 && first !== void 0 && sortedHostnames.some((hostname) => !hostStatesEqual(hostname.projectedState, first.projectedState) || !hostStatesEqual(hostname.expectedPreviousState, first.expectedPreviousState))) throw new Error("Route authority service projection must share one HostState");
 	const parsed = {
 		contractVersion: envelope.contractVersion,
 		cellId,
@@ -1071,6 +1127,7 @@ const parseRouteProjectionIntent = flow(rejectForbiddenKeys, decodeRouteProjecti
 		operationId,
 		routeFence,
 		zoneId,
+		...service,
 		hostnames: sortedHostnames
 	};
 	if (new TextEncoder().encode(canonicalJson(parsed)).byteLength > MAX_CONTRACT_BYTES) throw new Error("Route authority projection intent is too large");
@@ -1137,12 +1194,26 @@ const parseRouteProjectionReceipt = flow(rejectForbiddenKeys, decodeRouteProject
 		hostnames: sortedHostnames
 	};
 });
+/**
+* Which hostnames a finished operation projected, read without its HostStates.
+* A stored receipt keeps the HostState shape that was current when it was
+* written, and a PROMOTED migration from before v2 can still name a Service's
+* active deployment (#1318). The redeploy path and the script reaper need only
+* the hostnames, so they must not depend on a shape the contract dropped.
+*/
+const parseRouteProjectionReceiptOutcome = flow(rejectForbiddenKeys, decodeRouteProjectionReceipt, (envelope) => ({
+	result: envelope.result,
+	hostnames: envelope.hostnames.map((entry) => normalizeHostname(decodeHostnameReceipt(entry).hostname))
+}));
 async function sha256Hex(value) {
 	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(value));
 	return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
 }
 /** Read the immutable target fields of a mapping; callers validate its expiry separately. */
 const parseWorkerDeploymentMappingTarget = flow(contractDecoder(Record(String, Unknown), "Worker deployment mapping is invalid"), ({ expiresAt: _expiresAt, ...target }) => parseWorkerDeploymentTarget(target));
+function hostStatesEqual(left, right) {
+	return canonicalJson(left) === canonicalJson(right);
+}
 
 //#endregion
 //#region ../../packages/providers/core/src/desired-state.ts

package/dist/edge-dev-worker.mjs

@@ -1,6 +1,6 @@
 import { $ as match, G as andThen, K as callback, _t as void_, at as raceFirst, et as never, ft as sync, lt as scoped, st as runPromise } from "./Schema-Cg34DK63.mjs";
-import "./veloz-config-iN8SFxrR.mjs";
-import { i as startEdgeDev, n as edgeDevOptionsSchema } from "./edge-dev-ATMqwxjd.mjs";
+import "./veloz-config-59H2mWOA.mjs";
+import { i as startEdgeDev, n as edgeDevOptionsSchema } from "./edge-dev-Wrtj1z2W.mjs";
 import { parentPort, workerData } from "node:worker_threads";
 
 //#region src/lib/edge-dev-worker.ts