@haakco/hostingctl 1.0.868 → 1.0.870
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/main.js +416 -205
- package/dist/main.js.map +1 -1
- package/package.json +1 -1
- package/platform/darwin-arm64/hostingctl +0 -0
- package/platform/darwin-x64/hostingctl +0 -0
- package/platform/linux-arm64/hostingctl +0 -0
- package/platform/linux-x64/hostingctl +0 -0
- package/platform/windows-x64/hostingctl.exe +0 -0
package/dist/main.js
CHANGED
|
@@ -44627,6 +44627,157 @@ function applicationAdminText(report) {
|
|
|
44627
44627
|
}
|
|
44628
44628
|
return recoveryLines$1(report.recovery).join("\n");
|
|
44629
44629
|
}
|
|
44630
|
+
// src/commands/application-image-text.ts
|
|
44631
|
+
/**
|
|
44632
|
+
* What an imported image release is, in the terminal's own lines.
|
|
44633
|
+
*
|
|
44634
|
+
* The panel renders the same provenance as prose; a terminal needs lines a person can compare, so the two
|
|
44635
|
+
* digests, the scan verdict and the architecture are one row each. Nothing here names an internal object
|
|
44636
|
+
* path, a registry credential or a connection secret.
|
|
44637
|
+
*/
|
|
44638
|
+
/** The scanner's answer, in the form a receipt states it. */
|
|
44639
|
+
function imageScanText(image) {
|
|
44640
|
+
const counts = `${String(image.scan.critical)} critical, ${String(image.scan.high)} high`;
|
|
44641
|
+
if (image.scan.status === "pending") return "pending — deployment unaffected";
|
|
44642
|
+
if (image.scan.status === "clean" || image.scan.status === "findings") return `completed — ${counts}`;
|
|
44643
|
+
return "unavailable — deployment unaffected";
|
|
44644
|
+
}
|
|
44645
|
+
/** The provenance lines for one imported image release, or none for a release built from source. */
|
|
44646
|
+
function imageProvenanceText(release) {
|
|
44647
|
+
const image = release.image;
|
|
44648
|
+
if (image === null) return [];
|
|
44649
|
+
const reference = image.sourceReference === "" ? image.sourceDigest : image.sourceReference;
|
|
44650
|
+
const separator = reference.startsWith("sha256:") ? "@" : ":";
|
|
44651
|
+
return [
|
|
44652
|
+
` image ${image.sourceHost}/${image.sourceRepository}${separator}${reference}`,
|
|
44653
|
+
` source digest ${image.sourceDigest}`,
|
|
44654
|
+
` stored digest ${image.internalDigest}`,
|
|
44655
|
+
` scan ${imageScanText(image)}`,
|
|
44656
|
+
` platform ${image.architecture}`
|
|
44657
|
+
];
|
|
44658
|
+
}
|
|
44659
|
+
/** The provenance of the release an application serves and of the one it is being asked to serve. */
|
|
44660
|
+
function deploymentImageText(releases) {
|
|
44661
|
+
return ["running", "requested"].flatMap((label) => {
|
|
44662
|
+
const release = releases[label];
|
|
44663
|
+
const lines = release === null ? [] : imageProvenanceText(release);
|
|
44664
|
+
return lines.length === 0 ? [] : [` ${label} image`, ...lines];
|
|
44665
|
+
});
|
|
44666
|
+
}
|
|
44667
|
+
/**
|
|
44668
|
+
* What preparing an image did, and what it has not done yet.
|
|
44669
|
+
*
|
|
44670
|
+
* Preparing records and verifies the import. Scanning is informational and does not delay readiness.
|
|
44671
|
+
* The receipt identifies the release to activate through the existing deployment operation. A deployment
|
|
44672
|
+
* receipt without a status still says it is preparing, rather than printing an empty column.
|
|
44673
|
+
*/
|
|
44674
|
+
function prepareImageText(result) {
|
|
44675
|
+
if (typeof result === "string") return ` ${result}`;
|
|
44676
|
+
const status = result.status === null || result.status === "" ? "preparing" : result.status;
|
|
44677
|
+
return [` release ${result.releaseUuid} ${status}`, " Import and verification continue in the background. Scanning does not delay readiness. Deploy the ready release; this command deploys nothing."].join("\n");
|
|
44678
|
+
}
|
|
44679
|
+
// src/commands/application-failure-text.ts
|
|
44680
|
+
/**
|
|
44681
|
+
* The path each answer was read for, kept beside the answer rather than inside it: the renderer receives only the
|
|
44682
|
+
* API's payload, and adding the path to that payload would change what `--json` prints.
|
|
44683
|
+
*/
|
|
44684
|
+
var answeredFor = /* @__PURE__ */ new WeakMap();
|
|
44685
|
+
/** Record which application an answer belongs to, so its text can name the exact follow-up command. */
|
|
44686
|
+
function rememberApplicationPath(report, path) {
|
|
44687
|
+
answeredFor.set(report, path);
|
|
44688
|
+
return report;
|
|
44689
|
+
}
|
|
44690
|
+
function applicationPathOf(report) {
|
|
44691
|
+
return answeredFor.get(report);
|
|
44692
|
+
}
|
|
44693
|
+
function present$1(value) {
|
|
44694
|
+
const trimmed = value?.trim() ?? "";
|
|
44695
|
+
return trimmed === "" ? null : trimmed;
|
|
44696
|
+
}
|
|
44697
|
+
/** Who has to act, in the one wording every failure surface uses. */
|
|
44698
|
+
function whoActsNext(owner) {
|
|
44699
|
+
return owner === "platform" ? "the platform — this is ours to fix" : "you";
|
|
44700
|
+
}
|
|
44701
|
+
/** Why an attempt stopped, who acts next and what to quote to support; no lines for an attempt that did not fail. */
|
|
44702
|
+
function failureLines$1(attempt) {
|
|
44703
|
+
const explanation = attempt.explanation ?? null;
|
|
44704
|
+
const reason = present$1(attempt.failureReason);
|
|
44705
|
+
const stage = present$1(attempt.failureStage);
|
|
44706
|
+
const reference = present$1(attempt.correlationId);
|
|
44707
|
+
const next = present$1(explanation?.nextAction);
|
|
44708
|
+
return [
|
|
44709
|
+
...explanation === null ? [] : [
|
|
44710
|
+
` Why: ${explanation.message}`,
|
|
44711
|
+
` Cause: ${explanation.cause}`,
|
|
44712
|
+
` Who acts next: ${whoActsNext(explanation.owner)}`,
|
|
44713
|
+
...next === null ? [] : [` What to do: ${next}`],
|
|
44714
|
+
` Retry: ${explanation.retryable ? "a retry can succeed" : "a retry will not help"}`
|
|
44715
|
+
],
|
|
44716
|
+
...explanation === null && reason !== null ? [` Recorded reason (the platform's record): ${reason}`] : [],
|
|
44717
|
+
...stage === null ? [] : [` Failed at: ${stage}`],
|
|
44718
|
+
...explanation !== null && reason !== null ? [` Platform's record: ${reason}`] : [],
|
|
44719
|
+
...reference === null ? [] : [` Reference to quote to support: ${reference}`]
|
|
44720
|
+
];
|
|
44721
|
+
}
|
|
44722
|
+
/** The command that reads one build attempt's retained output; placeholders only where no path was recorded. */
|
|
44723
|
+
function buildLogCommand(path, buildUuid) {
|
|
44724
|
+
return `hostingctl application build-log ${path?.environmentUuid ?? "<environment-uuid>"} ${path?.workloadUuid ?? "<application-uuid>"} ${buildUuid} --company ${path?.company ?? "<slug>"}`;
|
|
44725
|
+
}
|
|
44726
|
+
/** A stopped build's story, ending with where its output is. */
|
|
44727
|
+
function buildFailureLines(build, path) {
|
|
44728
|
+
const lines = failureLines$1(build);
|
|
44729
|
+
return lines.length === 0 ? [] : [...lines, ` Read this attempt's output: ${buildLogCommand(path, build.uuid)}`];
|
|
44730
|
+
}
|
|
44731
|
+
/** One build as a receipt: what it is, and when it stopped, why. */
|
|
44732
|
+
function buildText(build, path) {
|
|
44733
|
+
return [` build ${build.uuid} attempt ${String(build.attempt)} ${build.status}`, ...buildFailureLines(build, path)].join("\n");
|
|
44734
|
+
}
|
|
44735
|
+
/** What a failed release's own task printed, which the platform retains on the release itself. */
|
|
44736
|
+
function taskOutputLines(release) {
|
|
44737
|
+
const output = release.taskOutput ?? null;
|
|
44738
|
+
if (output === null) return [];
|
|
44739
|
+
return [
|
|
44740
|
+
" What the release task printed:",
|
|
44741
|
+
...output.truncated ? [" This is the beginning of the output: the task printed more than is retained."] : [],
|
|
44742
|
+
output.contents === "" ? " The release task printed nothing." : output.contents
|
|
44743
|
+
];
|
|
44744
|
+
}
|
|
44745
|
+
/** A stopped release's story, with the output its task left and its build's reference when one is known. */
|
|
44746
|
+
function releaseFailureLines(release, correlationId = null) {
|
|
44747
|
+
const lines = failureLines$1({
|
|
44748
|
+
...release,
|
|
44749
|
+
correlationId
|
|
44750
|
+
});
|
|
44751
|
+
return lines.length === 0 ? [] : [...lines, ...taskOutputLines(release)];
|
|
44752
|
+
}
|
|
44753
|
+
/** What a wait refuses with when the release it followed failed: its story, and where to read it again. */
|
|
44754
|
+
function failedReleaseMessage(path, key, release) {
|
|
44755
|
+
return [
|
|
44756
|
+
`Release ${release.uuid} of application ${key} did not become ready.`,
|
|
44757
|
+
...releaseFailureLines(release),
|
|
44758
|
+
`Read it with \`hostingctl application deployment ${path.environmentUuid} ${path.workloadUuid} --company ${path.company}\`.`
|
|
44759
|
+
].join("\n");
|
|
44760
|
+
}
|
|
44761
|
+
/** One release as a receipt: what it is, whether it will deploy, what it was verified as and why it stopped. */
|
|
44762
|
+
function releaseText(release) {
|
|
44763
|
+
return [
|
|
44764
|
+
` release ${release.uuid} ${release.status} running ${release.isRunning ? "yes" : "no"}`,
|
|
44765
|
+
...release.deployWaiting ? [" will deploy when the current change finishes"] : [],
|
|
44766
|
+
...imageProvenanceText(release),
|
|
44767
|
+
...releaseFailureLines(release)
|
|
44768
|
+
].join("\n");
|
|
44769
|
+
}
|
|
44770
|
+
/**
|
|
44771
|
+
* The two stopped attempts a deployment reports, as the panel's two warnings: the requested release that did not
|
|
44772
|
+
* become ready, and the last build that did not finish.
|
|
44773
|
+
*/
|
|
44774
|
+
function deploymentFailureLines(data, path) {
|
|
44775
|
+
const { requested, interrupted } = data;
|
|
44776
|
+
const reference = data.builds.find((one) => one.uuid === requested?.buildUuid)?.correlationId;
|
|
44777
|
+
const release = requested?.status === "failed" ? releaseFailureLines(requested, reference ?? null) : [];
|
|
44778
|
+
const build = interrupted === null ? [] : buildFailureLines(interrupted, path);
|
|
44779
|
+
return [...release.length === 0 ? [] : [`Requested release ${requested?.uuid ?? ""} did not become ready:`, ...release], ...build.length === 0 ? [] : [`Build ${interrupted?.uuid ?? ""} (attempt ${String(interrupted?.attempt)}) did not finish:`, ...build]];
|
|
44780
|
+
}
|
|
44630
44781
|
// src/commands/application-build-log.ts
|
|
44631
44782
|
/** The line of the build's own output that the platform picked out as its failure. */
|
|
44632
44783
|
function buildErrorLine(error) {
|
|
@@ -44637,7 +44788,7 @@ function logText(log) {
|
|
|
44637
44788
|
return [
|
|
44638
44789
|
...log.error === null ? [] : [buildErrorLine(log.error)],
|
|
44639
44790
|
` build ${log.buildUuid} attempt ${String(log.attempt)} ${String(log.status)}${log.available ? "" : ` (log unavailable: ${log.detail})`}`,
|
|
44640
|
-
...
|
|
44791
|
+
...failureLines$1(log),
|
|
44641
44792
|
...log.truncated ? [" the log was truncated by the platform"] : [],
|
|
44642
44793
|
...log.contents === null ? [] : [log.contents]
|
|
44643
44794
|
].join("\n");
|
|
@@ -44730,7 +44881,7 @@ async function deliverApplicationSource(progress, path, key, archive, deadline,
|
|
|
44730
44881
|
uploadUuid: upload.uuid,
|
|
44731
44882
|
buildUuid: build.uuid
|
|
44732
44883
|
});
|
|
44733
|
-
const { finished, running } = await followBuildToServing(progress, path, key, build, deadline, (failed) => `Read it with
|
|
44884
|
+
const { finished, running } = await followBuildToServing(progress, path, key, build, deadline, (failed) => `Read it with \`${buildLogCommand(path, failed.uuid)}\`; its upload and build are kept.`, (releaseUuid) => record({
|
|
44734
44885
|
key,
|
|
44735
44886
|
workloadUuid: path.workloadUuid,
|
|
44736
44887
|
uploadUuid: upload.uuid,
|
|
@@ -44798,6 +44949,7 @@ async function awaitRelease(progress, path, key, releaseUuid, deadline) {
|
|
|
44798
44949
|
return running;
|
|
44799
44950
|
}
|
|
44800
44951
|
const release = observed.releases.find((one) => one.uuid === releaseUuid);
|
|
44952
|
+
if (release?.status === "failed") throw new ApiError(422, failedReleaseMessage(path, key, release));
|
|
44801
44953
|
const build = observed.builds.find((one) => one.uuid === release?.buildUuid);
|
|
44802
44954
|
if (release?.status === "ready" && build?.deployMode === "candidate") throw new ApiError(422, `Release ${releaseUuid} of application ${key} is built but was not deployed. Deploy it with \`hostingctl application deploy ${path.environmentUuid} ${path.workloadUuid} ${releaseUuid} --company <slug> --confirm\`.`);
|
|
44803
44955
|
progress.report(`${key}: release ${releaseUuid} ${release?.deployWaiting === true ? "will deploy when the current change finishes" : running === null ? "not running yet" : `waiting (${running.status} of ${running.uuid})`}`);
|
|
@@ -44815,14 +44967,14 @@ function buildOf(deployment, uuid) {
|
|
|
44815
44967
|
* build failed on comes first, because it is the one a person acts on.
|
|
44816
44968
|
*/
|
|
44817
44969
|
async function buildRefusal(path, key, build, next) {
|
|
44818
|
-
const reason = [build.failureStage, build.failureReason].filter((one) => one !== null && one !== "");
|
|
44819
44970
|
const line = await failedBuildLine({
|
|
44820
44971
|
...path,
|
|
44821
44972
|
buildUuid: build.uuid
|
|
44822
44973
|
});
|
|
44823
44974
|
return new ApiError(422, [
|
|
44824
44975
|
...line === null ? [] : [line],
|
|
44825
|
-
`Build ${build.uuid} of application ${key} finished ${build.status}
|
|
44976
|
+
`Build ${build.uuid} of application ${key} finished ${build.status}.`,
|
|
44977
|
+
...failureLines$1(build),
|
|
44826
44978
|
next(build)
|
|
44827
44979
|
].join("\n"));
|
|
44828
44980
|
}
|
|
@@ -44859,7 +45011,7 @@ var BUILD_WAIT_DESCRIPTION = "Then wait for it and deploy its release once it su
|
|
|
44859
45011
|
async function waitForBuild(context, path, build, deadline) {
|
|
44860
45012
|
context.progress.start();
|
|
44861
45013
|
try {
|
|
44862
|
-
const { finished, running } = await followBuildToServing(context.progress, path, path.workloadUuid, build, deadline, (failed) => `Read the whole log with
|
|
45014
|
+
const { finished, running } = await followBuildToServing(context.progress, path, path.workloadUuid, build, deadline, (failed) => `Read the whole log with \`${buildLogCommand(path, failed.uuid)}\`.`);
|
|
44863
45015
|
return {
|
|
44864
45016
|
kind: "build-wait",
|
|
44865
45017
|
buildUuid: build.uuid,
|
|
@@ -45143,21 +45295,18 @@ function optionalFlag$1(context, flag) {
|
|
|
45143
45295
|
return value === "" ? null : value;
|
|
45144
45296
|
}
|
|
45145
45297
|
/** The write receipt: a build's own fields, or the deployment's source. */
|
|
45146
|
-
function writeText$6(report) {
|
|
45298
|
+
function writeText$6(report, path) {
|
|
45147
45299
|
const { outcome } = report;
|
|
45148
45300
|
if (!outcome.sent) return `Would: ${outcome.description}\nNothing was sent (--dry-run).`;
|
|
45149
45301
|
const value = outcome.result;
|
|
45150
|
-
if (typeof value.uuid === "string") {
|
|
45151
|
-
const failure = typeof value.failureReason === "string" ? ` — ${value.failureReason}` : "";
|
|
45152
|
-
return `${outcome.description}\n build ${value.uuid} ${String(value.status)}${failure}`;
|
|
45153
|
-
}
|
|
45302
|
+
if (typeof value.uuid === "string") return `${outcome.description}\n${buildText(outcome.result, path)}`;
|
|
45154
45303
|
const source = value.source;
|
|
45155
45304
|
return `${outcome.description}\n source ${source === null || source === void 0 ? "unbound" : source.branch ?? "detached"}`;
|
|
45156
45305
|
}
|
|
45157
45306
|
/** The `application build-*|source-*` renderer. */
|
|
45158
|
-
function applicationBuildText(report) {
|
|
45307
|
+
function applicationBuildText(report, path) {
|
|
45159
45308
|
if (report.kind === "build-wait") return buildWaitText(report);
|
|
45160
|
-
return report.kind === "build-write" ? writeText$6(report) : logText(report.log);
|
|
45309
|
+
return report.kind === "build-write" ? writeText$6(report, path) : logText(report.log);
|
|
45161
45310
|
}
|
|
45162
45311
|
// src/commands/application-cache-rules.ts
|
|
45163
45312
|
/** The `cache-set` flags that replace an application's ordered cache rules. */
|
|
@@ -45932,6 +46081,34 @@ function recoveryLines(one) {
|
|
|
45932
46081
|
` recovery ${one.uuid}`
|
|
45933
46082
|
].join("\n");
|
|
45934
46083
|
}
|
|
46084
|
+
// src/commands/application-container-issues-text.ts
|
|
46085
|
+
/**
|
|
46086
|
+
* Why an application's own containers are not ready, as the capacity read states it.
|
|
46087
|
+
*
|
|
46088
|
+
* Three answers, kept apart: the containers were not read, they were read and nothing is wrong, or each one that
|
|
46089
|
+
* is not ready with the API's own sentence and next action. An API that predates the field answers nothing, which
|
|
46090
|
+
* is "not measured" too: an unread container must never read as a healthy one.
|
|
46091
|
+
*/
|
|
46092
|
+
function containerIssueLines(issues) {
|
|
46093
|
+
if (issues === null || issues === void 0) return [" container health: not measured"];
|
|
46094
|
+
if (issues.length === 0) return [" container health: every container is ready"];
|
|
46095
|
+
return issues.flatMap(containerIssueBlock);
|
|
46096
|
+
}
|
|
46097
|
+
/** Who acts and how: the platform says the issue is its own, a client gets the action when the API states one. */
|
|
46098
|
+
function nextLine(issue) {
|
|
46099
|
+
return issue.owner === "client" && issue.nextAction !== null ? ` What to do: ${issue.nextAction}` : ` Who acts next: ${whoActsNext(issue.owner)}`;
|
|
46100
|
+
}
|
|
46101
|
+
/** One container that is not ready: which one and its state, the reason, who acts, then what support asks for. */
|
|
46102
|
+
function containerIssueBlock(issue) {
|
|
46103
|
+
const process = issue.process === null ? "" : ` (process ${issue.process})`;
|
|
46104
|
+
const exit = issue.lastExitCode === null ? "" : ` last exit code ${String(issue.lastExitCode)}`;
|
|
46105
|
+
return [
|
|
46106
|
+
` container ${issue.container}${process}: ${issue.state}`,
|
|
46107
|
+
` Why: ${issue.message}`,
|
|
46108
|
+
nextLine(issue),
|
|
46109
|
+
` Restarts: ${String(issue.restartCount)}${exit}`
|
|
46110
|
+
];
|
|
46111
|
+
}
|
|
45935
46112
|
// src/commands/application-capacity.ts
|
|
45936
46113
|
var CAPACITY_USAGE = [
|
|
45937
46114
|
"Usage: hostingctl application capacity <environment-uuid> <application-uuid> --company <slug> [--json]",
|
|
@@ -45957,7 +46134,8 @@ async function applicationCapacity(path) {
|
|
|
45957
46134
|
* The finding as the API stated it: the rung as a title, then the reason and the recommendation verbatim.
|
|
45958
46135
|
*
|
|
45959
46136
|
* A signal the platform could not read is named on its own line, because a rung that no measurement established
|
|
45960
|
-
* is not a clean bill of health and must not be read as one.
|
|
46137
|
+
* is not a clean bill of health and must not be read as one. The containers' own state follows, because a rung
|
|
46138
|
+
* says how close the application is to a limit and not whether it is running at all.
|
|
45961
46139
|
*/
|
|
45962
46140
|
function applicationCapacityText(finding) {
|
|
45963
46141
|
const { decision, signals } = finding;
|
|
@@ -45965,7 +46143,8 @@ function applicationCapacityText(finding) {
|
|
|
45965
46143
|
`${signals.application}: ${RUNG_TITLES[decision.rung]}`,
|
|
45966
46144
|
` reason ${decision.reason}`,
|
|
45967
46145
|
` next step ${decision.recommendation}`,
|
|
45968
|
-
...signals.unmeasured.length === 0 ? [] : [` not measured ${signals.unmeasured.join(", ")}: this is not the same as healthy.`]
|
|
46146
|
+
...signals.unmeasured.length === 0 ? [] : [` not measured ${signals.unmeasured.join(", ")}: this is not the same as healthy.`],
|
|
46147
|
+
...containerIssueLines(signals.containerIssues)
|
|
45969
46148
|
].join("\n");
|
|
45970
46149
|
}
|
|
45971
46150
|
// src/commands/application-recovery-wait.ts
|
|
@@ -47493,55 +47672,6 @@ function schedulesText(schedules) {
|
|
|
47493
47672
|
return ` ${one.key} ${when} ${state} ${owner} last success ${one.lastSucceededAt ?? "never"} ${uses}`;
|
|
47494
47673
|
})].join("\n");
|
|
47495
47674
|
}
|
|
47496
|
-
// src/commands/application-image-text.ts
|
|
47497
|
-
/**
|
|
47498
|
-
* What an imported image release is, in the terminal's own lines.
|
|
47499
|
-
*
|
|
47500
|
-
* The panel renders the same provenance as prose; a terminal needs lines a person can compare, so the two
|
|
47501
|
-
* digests, the scan verdict and the architecture are one row each. Nothing here names an internal object
|
|
47502
|
-
* path, a registry credential or a connection secret.
|
|
47503
|
-
*/
|
|
47504
|
-
/** The scanner's answer, in the form a receipt states it. */
|
|
47505
|
-
function imageScanText(image) {
|
|
47506
|
-
const counts = `${String(image.scan.critical)} critical, ${String(image.scan.high)} high`;
|
|
47507
|
-
if (image.scan.status === "pending") return "pending — deployment unaffected";
|
|
47508
|
-
if (image.scan.status === "clean" || image.scan.status === "findings") return `completed — ${counts}`;
|
|
47509
|
-
return "unavailable — deployment unaffected";
|
|
47510
|
-
}
|
|
47511
|
-
/** The provenance lines for one imported image release, or none for a release built from source. */
|
|
47512
|
-
function imageProvenanceText(release) {
|
|
47513
|
-
const image = release.image;
|
|
47514
|
-
if (image === null) return [];
|
|
47515
|
-
const reference = image.sourceReference === "" ? image.sourceDigest : image.sourceReference;
|
|
47516
|
-
const separator = reference.startsWith("sha256:") ? "@" : ":";
|
|
47517
|
-
return [
|
|
47518
|
-
` image ${image.sourceHost}/${image.sourceRepository}${separator}${reference}`,
|
|
47519
|
-
` source digest ${image.sourceDigest}`,
|
|
47520
|
-
` stored digest ${image.internalDigest}`,
|
|
47521
|
-
` scan ${imageScanText(image)}`,
|
|
47522
|
-
` platform ${image.architecture}`
|
|
47523
|
-
];
|
|
47524
|
-
}
|
|
47525
|
-
/** The provenance of the release an application serves and of the one it is being asked to serve. */
|
|
47526
|
-
function deploymentImageText(releases) {
|
|
47527
|
-
return ["running", "requested"].flatMap((label) => {
|
|
47528
|
-
const release = releases[label];
|
|
47529
|
-
const lines = release === null ? [] : imageProvenanceText(release);
|
|
47530
|
-
return lines.length === 0 ? [] : [` ${label} image`, ...lines];
|
|
47531
|
-
});
|
|
47532
|
-
}
|
|
47533
|
-
/**
|
|
47534
|
-
* What preparing an image did, and what it has not done yet.
|
|
47535
|
-
*
|
|
47536
|
-
* Preparing records and verifies the import. Scanning is informational and does not delay readiness.
|
|
47537
|
-
* The receipt identifies the release to activate through the existing deployment operation. A deployment
|
|
47538
|
-
* receipt without a status still says it is preparing, rather than printing an empty column.
|
|
47539
|
-
*/
|
|
47540
|
-
function prepareImageText(result) {
|
|
47541
|
-
if (typeof result === "string") return ` ${result}`;
|
|
47542
|
-
const status = result.status === null || result.status === "" ? "preparing" : result.status;
|
|
47543
|
-
return [` release ${result.releaseUuid} ${status}`, " Import and verification continue in the background. Scanning does not delay readiness. Deploy the ready release; this command deploys nothing."].join("\n");
|
|
47544
|
-
}
|
|
47545
47675
|
// src/commands/application-source-ssh-text.ts
|
|
47546
47676
|
/**
|
|
47547
47677
|
* One SSH source as a person needs it, whether it is serving or not.
|
|
@@ -47601,11 +47731,11 @@ function applicationSshSourceText(report) {
|
|
|
47601
47731
|
// src/commands/application-text.ts
|
|
47602
47732
|
/** The `application` group's human rendering, each answer read from the API's own payload. */
|
|
47603
47733
|
/** Each group tags its own answers, so the kind names the renderer. */
|
|
47604
|
-
function taggedText$1(report) {
|
|
47734
|
+
function taggedText$1(report, path) {
|
|
47605
47735
|
if (report.kind === "updates" || report.kind === "updates-write") return applicationUpdatesText(report);
|
|
47606
47736
|
if (report.kind === "runtime-version-move") return runtimeVersionMoveText(report);
|
|
47607
47737
|
if (report.kind === "cache" || report.kind === "routes" || report.kind === "cache-write") return applicationCacheText(report);
|
|
47608
|
-
if (report.kind === "build-log" || report.kind === "build-write" || report.kind === "build-wait") return applicationBuildText(report);
|
|
47738
|
+
if (report.kind === "build-log" || report.kind === "build-write" || report.kind === "build-wait") return applicationBuildText(report, path);
|
|
47609
47739
|
if (report.kind === "site-access" || report.kind === "site-users" || report.kind === "site-write") return siteAccessText(report);
|
|
47610
47740
|
if (report.kind === "import" || report.kind === "url-repair" || report.kind === "import-write") return applicationImportText(report);
|
|
47611
47741
|
if (report.kind === "recovery-review" || report.kind === "recovery-write" || report.kind === "recovery-wait") return applicationRecoveryText(report);
|
|
@@ -47629,16 +47759,17 @@ function sourceGroupText(report) {
|
|
|
47629
47759
|
}
|
|
47630
47760
|
}
|
|
47631
47761
|
function applicationText(report) {
|
|
47762
|
+
const path = applicationPathOf(report);
|
|
47632
47763
|
if ("anonymousKey" in report) return report.anonymousKey;
|
|
47633
47764
|
if ("measurement" in report) return applicationSpeedText(report);
|
|
47634
47765
|
if ("signals" in report) return applicationCapacityText(report);
|
|
47635
|
-
if ("kind" in report) return sourceGroupText(report) ?? taggedText$1(report);
|
|
47636
|
-
if ("sent" in report) return renderWriteOutcome(report, writeAnyResultText);
|
|
47766
|
+
if ("kind" in report) return sourceGroupText(report) ?? taggedText$1(report, path);
|
|
47767
|
+
if ("sent" in report) return renderWriteOutcome(report, (result) => writeAnyResultText(result, path));
|
|
47637
47768
|
if ("applications" in report) return listText(report);
|
|
47638
47769
|
if ("runs" in report) return runsText(report);
|
|
47639
47770
|
if ("output" in report) return runLogText(report);
|
|
47640
47771
|
if ("inventoryDigest" in report) return removalReviewText(report);
|
|
47641
|
-
if ("builds" in report) return deploymentText(report);
|
|
47772
|
+
if ("builds" in report) return deploymentText(report, path);
|
|
47642
47773
|
if ("replicas" in report) return applicationDetailText(report);
|
|
47643
47774
|
return "";
|
|
47644
47775
|
}
|
|
@@ -47671,9 +47802,9 @@ function runtimeVersionText(app) {
|
|
|
47671
47802
|
const serving = app.runtimeVersionEffective ?? null;
|
|
47672
47803
|
return serving === null || serving === desired ? desired : `${desired} requested, ${serving} serving`;
|
|
47673
47804
|
}
|
|
47674
|
-
function deploymentText(data) {
|
|
47805
|
+
function deploymentText(data, path) {
|
|
47675
47806
|
const running = data.running === null ? "none" : `${data.running.uuid} (sequence ${String(data.running.sequence)})`;
|
|
47676
|
-
const requested = data.requested === null ? "none" : data.requested.uuid
|
|
47807
|
+
const requested = data.requested === null ? "none" : `${data.requested.uuid} (${data.requested.status})`;
|
|
47677
47808
|
const interrupted = data.interrupted === null ? "none" : `build ${data.interrupted.uuid} (${data.interrupted.status})`;
|
|
47678
47809
|
return [
|
|
47679
47810
|
` running ${running}`,
|
|
@@ -47686,12 +47817,10 @@ function deploymentText(data) {
|
|
|
47686
47817
|
...deploymentImageText({
|
|
47687
47818
|
running: data.running,
|
|
47688
47819
|
requested: data.requested
|
|
47689
|
-
})
|
|
47820
|
+
}),
|
|
47821
|
+
...deploymentFailureLines(data, path)
|
|
47690
47822
|
].join("\n");
|
|
47691
47823
|
}
|
|
47692
|
-
function buildText(build) {
|
|
47693
|
-
return [` build ${build.uuid} attempt ${String(build.attempt)} ${build.status}`, ` stage ${build.failureStage ?? "—"} ${build.failureReason ?? ""}`.trimEnd()].join("\n");
|
|
47694
|
-
}
|
|
47695
47824
|
function runsText(data) {
|
|
47696
47825
|
if (data.source === "unavailable") return `Process run history is unavailable: ${data.detail}`;
|
|
47697
47826
|
const runs = data.runs.length === 0 ? "No process runs recorded." : data.runs.map((one) => ` ${one.name} ${one.kind} ${one.status} ${one.startedAt ?? "not started"} ${one.durationSeconds === null ? "" : `${String(one.durationSeconds)}s`}`.trimEnd()).join("\n");
|
|
@@ -47718,19 +47847,15 @@ function createText(report) {
|
|
|
47718
47847
|
return `${outcome.description}\n${applicationDetailText(outcome.result)}`;
|
|
47719
47848
|
}
|
|
47720
47849
|
/** The write receipt, answering the API's own message when that is what came back. */
|
|
47721
|
-
function writeAnyResultText(result) {
|
|
47850
|
+
function writeAnyResultText(result, path) {
|
|
47722
47851
|
const value = result;
|
|
47723
47852
|
if (typeof value.message === "string" && typeof value.uuid !== "string") return ` ${value.message}`;
|
|
47724
|
-
return writeResultText$1(result);
|
|
47853
|
+
return writeResultText$1(result, path);
|
|
47725
47854
|
}
|
|
47726
|
-
function writeResultText$1(result) {
|
|
47727
|
-
if ("failureStage" in result) return buildText(result);
|
|
47855
|
+
function writeResultText$1(result, path) {
|
|
47856
|
+
if ("failureStage" in result) return buildText(result, path);
|
|
47728
47857
|
if ("releaseUuid" in result) return prepareImageText(result);
|
|
47729
|
-
if ("imageDigest" in result) return
|
|
47730
|
-
` release ${result.uuid} ${result.status} running ${result.isRunning ? "yes" : "no"}`,
|
|
47731
|
-
...result.deployWaiting ? [" will deploy when the current change finishes"] : [],
|
|
47732
|
-
...imageProvenanceText(result)
|
|
47733
|
-
].join("\n");
|
|
47858
|
+
if ("imageDigest" in result) return releaseText(result);
|
|
47734
47859
|
if ("runToken" in result) return ` ${result.message}`;
|
|
47735
47860
|
if ("statusName" in result) return ` removal ${result.uuid} ${result.statusName} open ${result.isOpen ? "yes" : "no"}`;
|
|
47736
47861
|
return applicationDetailText(result);
|
|
@@ -47767,11 +47892,12 @@ async function journey(context) {
|
|
|
47767
47892
|
environmentUuid
|
|
47768
47893
|
}, [workloadUuid, ...extra].filter((one) => one !== void 0));
|
|
47769
47894
|
if (workloadUuid === void 0) throw new UsageError(APPLICATION_USAGE);
|
|
47770
|
-
|
|
47895
|
+
const path = {
|
|
47771
47896
|
company,
|
|
47772
47897
|
environmentUuid,
|
|
47773
47898
|
workloadUuid
|
|
47774
|
-
}
|
|
47899
|
+
};
|
|
47900
|
+
return rememberApplicationPath(await dispatched$2(context, action, path, extra), path);
|
|
47775
47901
|
}
|
|
47776
47902
|
/** The actions that name one application, once its path is resolved. */
|
|
47777
47903
|
async function dispatched$2(context, action, path, extra) {
|
|
@@ -55768,7 +55894,7 @@ var billingAmountBasisEnumSchema = _enum([
|
|
|
55768
55894
|
"per_month",
|
|
55769
55895
|
"once_off",
|
|
55770
55896
|
"per_month_including_vat"
|
|
55771
|
-
]).describe("What one rate amount is for, and whether the amount already includes VAT. A recurring packaging price is charged per month and prorated by time held; a setup price is charged once for an approved event and is never prorated. A **VAT-inclusive** recurring price is the third case, and it exists because some prices are agreed as a consumer figure: R3.00 per 10 GB including VAT cannot be expressed as a whole number of net cents that reproduces R30.00 for ten blocks, so the agreed gross figure is what the price book stores and the VAT is separated out of it. That keeps a quote and an invoice equal to the number the client was given, instead of two cents away from it.
|
|
55897
|
+
]).describe("What one rate amount is for, and whether the amount already includes VAT. A recurring packaging price is charged per month and prorated by time held; a setup price is charged once for an approved event and is never prorated. A **VAT-inclusive** recurring price is the third case, and it exists because some prices are agreed as a consumer figure: R3.00 per 10 GB including VAT cannot be expressed as a whole number of net cents that reproduces R30.00 for ten blocks, so the agreed gross figure is what the price book stores and the VAT is separated out of it. That keeps a quote and an invoice equal to the number the client was given, instead of two cents away from it. Keeping all three in one effective-dated price table means there is one place a price lives, not three.\n");
|
|
55772
55898
|
var billingAmountsDataSchema = object({
|
|
55773
55899
|
netCents: int(),
|
|
55774
55900
|
vatCents: int(),
|
|
@@ -55815,13 +55941,13 @@ var billingCollectionReceiptStateEnumSchema = _enum([
|
|
|
55815
55941
|
"allocated",
|
|
55816
55942
|
"unallocated",
|
|
55817
55943
|
"reversed"
|
|
55818
|
-
]).describe("What a verified receipt is doing on its invoice. `unallocated` is a real answer, not a failure: a second genuine payment for an invoice that was already settled is kept for resolution rather than discarded, and money recorded from outside a Hosting attempt waits until an operator attributes it.\n| |\n|---|\n| `allocated` <br/>
|
|
55944
|
+
]).describe("What a verified receipt is doing on its invoice. `unallocated` is a real answer, not a failure: a second genuine payment for an invoice that was already settled is kept for resolution rather than discarded, and money recorded from outside a Hosting attempt waits until an operator attributes it.\n| |\n|---|\n| `allocated` <br/> |\n| `unallocated` <br/> |\n| `reversed` <br/> The money came back: a refund or a dispute an operator established and attributed. |");
|
|
55819
55945
|
var billingCollectionReceiptDataSchema = object({
|
|
55820
55946
|
uuid: string(),
|
|
55821
55947
|
amountCents: int(),
|
|
55822
55948
|
currency: string(),
|
|
55823
55949
|
source: billingCollectionReceiptSourceEnumSchema.describe("How a verified receipt came to exist. `automatic` is a receipt the provider reported for a Hosting instruction. `recorded` is money an operator attributed from outside Hosting, such as a bank line. `reconciled` is a receipt that settles a previously unresolved attempt using an authoritative provider observation. None of these can fabricate gateway evidence: every case names who or what established the receipt.\n"),
|
|
55824
|
-
state: billingCollectionReceiptStateEnumSchema.describe("What a verified receipt is doing on its invoice. `unallocated` is a real answer, not a failure: a second genuine payment for an invoice that was already settled is kept for resolution rather than discarded, and money recorded from outside a Hosting attempt waits until an operator attributes it.\n| |\n|---|\n| `allocated` <br/>
|
|
55950
|
+
state: billingCollectionReceiptStateEnumSchema.describe("What a verified receipt is doing on its invoice. `unallocated` is a real answer, not a failure: a second genuine payment for an invoice that was already settled is kept for resolution rather than discarded, and money recorded from outside a Hosting attempt waits until an operator attributes it.\n| |\n|---|\n| `allocated` <br/> |\n| `unallocated` <br/> |\n| `reversed` <br/> The money came back: a refund or a dispute an operator established and attributed. |"),
|
|
55825
55951
|
receivedAt: string(),
|
|
55826
55952
|
allocatedAt: string().nullable(),
|
|
55827
55953
|
reversedAt: string().nullable(),
|
|
@@ -55911,10 +56037,10 @@ var billingCreditEntryTypeEnumSchema = _enum([
|
|
|
55911
56037
|
"refunded_to_customer",
|
|
55912
56038
|
"applied_to_invoice",
|
|
55913
56039
|
"application_reversed"
|
|
55914
|
-
]).describe("The whole vocabulary of customer-credit ledger entries. Three, not a menu. A positive entry recognizes money we hold for a client — either cash that became refundable when a credit note was issued, or a receipt the allocator left unallocated. A negative entry discharges exactly one positive entry, so a refund can never be recorded twice or without a source.
|
|
56040
|
+
]).describe("The whole vocabulary of customer-credit ledger entries. Three, not a menu. A positive entry recognizes money we hold for a client — either cash that became refundable when a credit note was issued, or a receipt the allocator left unallocated. A negative entry discharges exactly one positive entry, so a refund can never be recorded twice or without a source. Slugs are stable because the database's shape constraint is built from the seeded ids; renaming one is a migration, not an edit.\n");
|
|
55915
56041
|
var billingCreditLedgerEntryDataSchema = object({
|
|
55916
56042
|
uuid: string(),
|
|
55917
|
-
type: billingCreditEntryTypeEnumSchema.describe("The whole vocabulary of customer-credit ledger entries. Three, not a menu. A positive entry recognizes money we hold for a client — either cash that became refundable when a credit note was issued, or a receipt the allocator left unallocated. A negative entry discharges exactly one positive entry, so a refund can never be recorded twice or without a source.
|
|
56043
|
+
type: billingCreditEntryTypeEnumSchema.describe("The whole vocabulary of customer-credit ledger entries. Three, not a menu. A positive entry recognizes money we hold for a client — either cash that became refundable when a credit note was issued, or a receipt the allocator left unallocated. A negative entry discharges exactly one positive entry, so a refund can never be recorded twice or without a source. Slugs are stable because the database's shape constraint is built from the seeded ids; renaming one is a migration, not an edit.\n"),
|
|
55918
56044
|
amountCents: int(),
|
|
55919
56045
|
currency: string(),
|
|
55920
56046
|
occurredAt: string(),
|
|
@@ -56023,7 +56149,7 @@ var billingVendorStatusEnumSchema = _enum([
|
|
|
56023
56149
|
"not_registered",
|
|
56024
56150
|
"registered"
|
|
56025
56151
|
]).describe("Whether the client is a VAT-registered vendor. s20 requires the recipient's VAT number only where they are registered, so an unknown status must never be read as \"not registered\": it is surfaced as a missing particular instead.\n");
|
|
56026
|
-
var billingPaymentTimingEnumSchema = _enum(["pre_pay", "post_pay"]).describe("When a client is invoiced for the month it is served. Most of our clients pay before the service: the invoice is raised at the start of the month it prices, which is what makes the money arrive before the cost is incurred. Others are agreed to pay after it, and that is a commercial term per client rather than a platform-wide setting — so it is recorded on the client's billing identity, where the rest of \"how this client is invoiced\" already lives.
|
|
56152
|
+
var billingPaymentTimingEnumSchema = _enum(["pre_pay", "post_pay"]).describe("When a client is invoiced for the month it is served. Most of our clients pay before the service: the invoice is raised at the start of the month it prices, which is what makes the money arrive before the cost is incurred. Others are agreed to pay after it, and that is a commercial term per client rather than a platform-wide setting — so it is recorded on the client's billing identity, where the rest of \"how this client is invoiced\" already lives. It decides one thing only: whether a month must have ENDED before its document may be issued. `post_pay` keeps that requirement, because its supplies are only complete then. `pre_pay` issues once the month has STARTED, because what it sells is the month itself and the price is known on its first day.\n| |\n|---|\n| `pre_pay` <br/> Invoiced at the start of the month it prices, before the service is delivered. |\n| `post_pay` <br/> Invoiced after the month it prices has ended. The default, because it never bills ahead of supply. |");
|
|
56027
56153
|
var billingIssueEligibilityGapDataSchema = object({
|
|
56028
56154
|
particular: string(),
|
|
56029
56155
|
message: string()
|
|
@@ -56043,17 +56169,17 @@ object({
|
|
|
56043
56169
|
postalCode: string().nullable(),
|
|
56044
56170
|
countryCode: string().nullable(),
|
|
56045
56171
|
dueDays: int().nullable(),
|
|
56046
|
-
paymentTiming: billingPaymentTimingEnumSchema.describe("When a client is invoiced for the month it is served. Most of our clients pay before the service: the invoice is raised at the start of the month it prices, which is what makes the money arrive before the cost is incurred. Others are agreed to pay after it, and that is a commercial term per client rather than a platform-wide setting — so it is recorded on the client's billing identity, where the rest of \"how this client is invoiced\" already lives.
|
|
56172
|
+
paymentTiming: billingPaymentTimingEnumSchema.describe("When a client is invoiced for the month it is served. Most of our clients pay before the service: the invoice is raised at the start of the month it prices, which is what makes the money arrive before the cost is incurred. Others are agreed to pay after it, and that is a commercial term per client rather than a platform-wide setting — so it is recorded on the client's billing identity, where the rest of \"how this client is invoiced\" already lives. It decides one thing only: whether a month must have ENDED before its document may be issued. `post_pay` keeps that requirement, because its supplies are only complete then. `pre_pay` issues once the month has STARTED, because what it sells is the month itself and the price is known on its first day.\n| |\n|---|\n| `pre_pay` <br/> Invoiced at the start of the month it prices, before the service is delivered. |\n| `post_pay` <br/> Invoiced after the month it prices has ended. The default, because it never bills ahead of supply. |"),
|
|
56047
56173
|
fullInvoiceGaps: array(billingIssueEligibilityGapDataSchema)
|
|
56048
56174
|
});
|
|
56049
56175
|
var billingDeliveryStateEnumSchema = _enum([
|
|
56050
56176
|
"not_sent",
|
|
56051
56177
|
"sent",
|
|
56052
56178
|
"failed"
|
|
56053
|
-
]).describe("What we know about sending the document. The mail transport can prove submission, not mailbox delivery, so `sent` means \"the transport
|
|
56054
|
-
var billingDiscountKindEnumSchema = _enum(["amount", "percent"]).describe("What a discount code states: a price, or a share off the list price. A code's promise is an **amount**, because an amount is what a client is charged and what a price window records. A percentage is therefore a way of *deriving* that amount once, at the month the window opens, against the list price effective then — not a second pricing rule that would reprice a settled month when a list price moves.
|
|
56179
|
+
]).describe("What we know about sending the document. The mail transport can prove submission, not mailbox delivery, so `sent` means \"the transport * accepted it for the billing contact\". A failed or missing contact never un-issues the document.\n");
|
|
56180
|
+
var billingDiscountKindEnumSchema = _enum(["amount", "percent"]).describe("What a discount code states: a price, or a share off the list price. A code's promise is an **amount**, because an amount is what a client is charged and what a price window records. A percentage is therefore a way of *deriving* that amount once, at the month the window opens, against the list price effective then — not a second pricing rule that would reprice a settled month when a list price moves. The kind is stored rather than inferred from which column is filled, so a half-written code cannot mean two things and an existing row keeps its original meaning as `amount`.\n");
|
|
56055
56181
|
var billingDiscountCodeRedemptionDataSchema = object({
|
|
56056
|
-
state: _enum(["pending", "applied"]).describe("Whether a redeemed code has priced the account yet. A code can be redeemed before the account holds anything to price: a client types it while creating their account, and a brand-new company has no environment, so no purchase period, so nothing a price window could name. `pending` is that state — the promise exists and is spent, and the first environment the client creates prices it. `applied` is a redemption that already wrote the company's price window.
|
|
56182
|
+
state: _enum(["pending", "applied"]).describe("Whether a redeemed code has priced the account yet. A code can be redeemed before the account holds anything to price: a client types it while creating their account, and a brand-new company has no environment, so no purchase period, so nothing a price window could name. `pending` is that state — the promise exists and is spent, and the first environment the client creates prices it. `applied` is a redemption that already wrote the company's price window. The distinction is a fact about the record, not a workflow step a caller advances by hand: only the environment creation path moves a redemption from `pending` to `applied`, in the transaction that opens the period.\n| |\n|---|\n| `pending` <br/> Redeemed, and waiting for the account to hold a package that can be priced. |\n| `applied` <br/> Redeemed, and the company's own price window carries the code's amount. |").describe("Whether a redeemed code has priced the account yet. A code can be redeemed before the account holds anything to price: a client types it while creating their account, and a brand-new company has no environment, so no purchase period, so nothing a price window could name. `pending` is that state — the promise exists and is spent, and the first environment the client creates prices it. `applied` is a redemption that already wrote the company's price window. The distinction is a fact about the record, not a workflow step a caller advances by hand: only the environment creation path moves a redemption from `pending` to `applied`, in the transaction that opens the period.\n| |\n|---|\n| `pending` <br/> Redeemed, and waiting for the account to hold a package that can be priced. |\n| `applied` <br/> Redeemed, and the company's own price window carries the code's amount. |"),
|
|
56057
56183
|
code: string(),
|
|
56058
56184
|
companySlug: string(),
|
|
56059
56185
|
amountCents: int().nullable(),
|
|
@@ -56066,7 +56192,7 @@ var billingDiscountCodeRedemptionDataSchema = object({
|
|
|
56066
56192
|
var billingDiscountCodeDataSchema = object({
|
|
56067
56193
|
uuid: string(),
|
|
56068
56194
|
code: string(),
|
|
56069
|
-
kind: billingDiscountKindEnumSchema.describe("What a discount code states: a price, or a share off the list price. A code's promise is an **amount**, because an amount is what a client is charged and what a price window records. A percentage is therefore a way of *deriving* that amount once, at the month the window opens, against the list price effective then — not a second pricing rule that would reprice a settled month when a list price moves.
|
|
56195
|
+
kind: billingDiscountKindEnumSchema.describe("What a discount code states: a price, or a share off the list price. A code's promise is an **amount**, because an amount is what a client is charged and what a price window records. A percentage is therefore a way of *deriving* that amount once, at the month the window opens, against the list price effective then — not a second pricing rule that would reprice a settled month when a list price moves. The kind is stored rather than inferred from which column is filled, so a half-written code cannot mean two things and an existing row keeps its original meaning as `amount`.\n"),
|
|
56070
56196
|
product: billingProductEnumSchema.describe("The tariff lines our documents define. `MHU` is the recurring managed hosting unit; `MHS` is the one-off managed hosting setup. `STO` is one recurring 10 GB storage block and `TRF` is one recurring chargeable 10 GB transfer block; the product variant (object storage, disk) is the rate's `package_key`, which is the price book's existing scope. `SUN` is a staff-issued sundry or time line, also selectable in the existing one-off price book. Product codes describe what a document bills as, while package keys scope the agreed price.\n"),
|
|
56071
56197
|
packageKey: string().nullable(),
|
|
56072
56198
|
amountCents: int().nullable(),
|
|
@@ -56201,7 +56327,7 @@ var billingInvoiceDataSchema = object({
|
|
|
56201
56327
|
storageFailureReason: string().nullable(),
|
|
56202
56328
|
pdfChecksum: string().nullable(),
|
|
56203
56329
|
pdfVerifiedAt: string().nullable(),
|
|
56204
|
-
deliveryState: billingDeliveryStateEnumSchema.describe("What we know about sending the document. The mail transport can prove submission, not mailbox delivery, so `sent` means \"the transport
|
|
56330
|
+
deliveryState: billingDeliveryStateEnumSchema.describe("What we know about sending the document. The mail transport can prove submission, not mailbox delivery, so `sent` means \"the transport * accepted it for the billing contact\". A failed or missing contact never un-issues the document.\n"),
|
|
56205
56331
|
paymentState: billingPaymentStateEnumSchema.describe("Whether a person has recorded money as received. Phase 1 takes no money and acts on nothing: this is a statement a human made, with the source that distinguishes an assumption from an observation.\n"),
|
|
56206
56332
|
paymentStateSource: billingPaymentStateSourceEnumSchema.describe("Why the payment state says what it says. `assumed` is the default a new invoice carries so invoicing never waits on a payment workflow. It is deliberately not evidence of receipt: no receipt, bank line or settlement timestamp is fabricated from it. `manual` is a person recording what they know. `collecting` is an invoice an authorized method is expected to pay, so it is unpaid and pending a verified receipt — never a person's statement. `collected` is a verified receipt that allocated to the invoice, and no person can claim it.\n")
|
|
56207
56333
|
});
|
|
@@ -56221,7 +56347,7 @@ object({
|
|
|
56221
56347
|
issuedAt: string().nullable(),
|
|
56222
56348
|
voidedAt: string().nullable(),
|
|
56223
56349
|
voidReason: string().nullable(),
|
|
56224
|
-
deliveryState: billingDeliveryStateEnumSchema.describe("What we know about sending the document. The mail transport can prove submission, not mailbox delivery, so `sent` means \"the transport
|
|
56350
|
+
deliveryState: billingDeliveryStateEnumSchema.describe("What we know about sending the document. The mail transport can prove submission, not mailbox delivery, so `sent` means \"the transport * accepted it for the billing contact\". A failed or missing contact never un-issues the document.\n"),
|
|
56225
56351
|
paymentState: billingPaymentStateEnumSchema.describe("Whether a person has recorded money as received. Phase 1 takes no money and acts on nothing: this is a statement a human made, with the source that distinguishes an assumption from an observation.\n"),
|
|
56226
56352
|
paymentStateSource: billingPaymentStateSourceEnumSchema.describe("Why the payment state says what it says. `assumed` is the default a new invoice carries so invoicing never waits on a payment workflow. It is deliberately not evidence of receipt: no receipt, bank line or settlement timestamp is fabricated from it. `manual` is a person recording what they know. `collecting` is an invoice an authorized method is expected to pay, so it is unpaid and pending a verified receipt — never a person's statement. `collected` is a verified receipt that allocated to the invoice, and no person can claim it.\n")
|
|
56227
56353
|
})),
|
|
@@ -56329,7 +56455,7 @@ var billingRateExistingCustomerRuleEnumSchema = _enum(["grandfathered", "applies
|
|
|
56329
56455
|
object({
|
|
56330
56456
|
product: billingProductEnumSchema.describe("The tariff lines our documents define. `MHU` is the recurring managed hosting unit; `MHS` is the one-off managed hosting setup. `STO` is one recurring 10 GB storage block and `TRF` is one recurring chargeable 10 GB transfer block; the product variant (object storage, disk) is the rate's `package_key`, which is the price book's existing scope. `SUN` is a staff-issued sundry or time line, also selectable in the existing one-off price book. Product codes describe what a document bills as, while package keys scope the agreed price.\n"),
|
|
56331
56457
|
packageKey: string(),
|
|
56332
|
-
amountBasis: billingAmountBasisEnumSchema.describe("What one rate amount is for, and whether the amount already includes VAT. A recurring packaging price is charged per month and prorated by time held; a setup price is charged once for an approved event and is never prorated. A **VAT-inclusive** recurring price is the third case, and it exists because some prices are agreed as a consumer figure: R3.00 per 10 GB including VAT cannot be expressed as a whole number of net cents that reproduces R30.00 for ten blocks, so the agreed gross figure is what the price book stores and the VAT is separated out of it. That keeps a quote and an invoice equal to the number the client was given, instead of two cents away from it.
|
|
56458
|
+
amountBasis: billingAmountBasisEnumSchema.describe("What one rate amount is for, and whether the amount already includes VAT. A recurring packaging price is charged per month and prorated by time held; a setup price is charged once for an approved event and is never prorated. A **VAT-inclusive** recurring price is the third case, and it exists because some prices are agreed as a consumer figure: R3.00 per 10 GB including VAT cannot be expressed as a whole number of net cents that reproduces R30.00 for ten blocks, so the agreed gross figure is what the price book stores and the VAT is separated out of it. That keeps a quote and an invoice equal to the number the client was given, instead of two cents away from it. Keeping all three in one effective-dated price table means there is one place a price lives, not three.\n"),
|
|
56333
56459
|
currentAmountCents: int(),
|
|
56334
56460
|
newAmountCents: int(),
|
|
56335
56461
|
isIncrease: boolean(),
|
|
@@ -56386,7 +56512,7 @@ object({ items: array(object({
|
|
|
56386
56512
|
companySlug: string().nullable(),
|
|
56387
56513
|
product: billingProductEnumSchema.describe("The tariff lines our documents define. `MHU` is the recurring managed hosting unit; `MHS` is the one-off managed hosting setup. `STO` is one recurring 10 GB storage block and `TRF` is one recurring chargeable 10 GB transfer block; the product variant (object storage, disk) is the rate's `package_key`, which is the price book's existing scope. `SUN` is a staff-issued sundry or time line, also selectable in the existing one-off price book. Product codes describe what a document bills as, while package keys scope the agreed price.\n"),
|
|
56388
56514
|
packageKey: string().nullable(),
|
|
56389
|
-
amountBasis: billingAmountBasisEnumSchema.describe("What one rate amount is for, and whether the amount already includes VAT. A recurring packaging price is charged per month and prorated by time held; a setup price is charged once for an approved event and is never prorated. A **VAT-inclusive** recurring price is the third case, and it exists because some prices are agreed as a consumer figure: R3.00 per 10 GB including VAT cannot be expressed as a whole number of net cents that reproduces R30.00 for ten blocks, so the agreed gross figure is what the price book stores and the VAT is separated out of it. That keeps a quote and an invoice equal to the number the client was given, instead of two cents away from it.
|
|
56515
|
+
amountBasis: billingAmountBasisEnumSchema.describe("What one rate amount is for, and whether the amount already includes VAT. A recurring packaging price is charged per month and prorated by time held; a setup price is charged once for an approved event and is never prorated. A **VAT-inclusive** recurring price is the third case, and it exists because some prices are agreed as a consumer figure: R3.00 per 10 GB including VAT cannot be expressed as a whole number of net cents that reproduces R30.00 for ten blocks, so the agreed gross figure is what the price book stores and the VAT is separated out of it. That keeps a quote and an invoice equal to the number the client was given, instead of two cents away from it. Keeping all three in one effective-dated price table means there is one place a price lives, not three.\n"),
|
|
56390
56516
|
amountCents: int(),
|
|
56391
56517
|
currency: string(),
|
|
56392
56518
|
effectiveFrom: string(),
|
|
@@ -56532,7 +56658,7 @@ var hostingSourceKindEnumSchema = _enum([
|
|
|
56532
56658
|
"upload",
|
|
56533
56659
|
"ssh"
|
|
56534
56660
|
]).describe("Where an application's source code came from. The value is recorded on the build attempt, not only on the application, because the attempt is what the platform can already prove: a build row keeps its own provenance after the binding or the connection behind it is replaced. `github` is the original GitHub App path; `upload` is a client-supplied ZIP and `ssh` is a Git repository fetched over SSH with a deploy key.\n");
|
|
56535
|
-
var hostingTagRuleEnumSchema = _enum(["exact", "line"]).describe("How a binding follows the tag it names. `EXACT` is \"this tag and no other\". `LINE` is \"newer tags in this line\", where the line is the major version — which is what makes a major bump the one thing a line will not walk across.
|
|
56661
|
+
var hostingTagRuleEnumSchema = _enum(["exact", "line"]).describe("How a binding follows the tag it names. `EXACT` is \"this tag and no other\". `LINE` is \"newer tags in this line\", where the line is the major version — which is what makes a major bump the one thing a line will not walk across. The decision is a method here rather than a service because it is a table of rules over two values, with no IO, no storage and no cluster: every row is provable with data, which is the cheapest rung this obligation has. It takes the tag a binding recorded and the tag a push delivered, because those are the two facts a delivery is judged against — and a tag that is legal when bound can always be followed by one that is not, so the judgement belongs at delivery.\n| |\n|---|\n| `exact` <br/> The binding follows the exact tag it named. |\n| `line` <br/> The binding follows newer stable tags in the same major line. |");
|
|
56536
56662
|
var bindHostingApplicationSourceRequestSchema = object({
|
|
56537
56663
|
sourceKind: union([hostingSourceKindEnumSchema, _null()]).optional(),
|
|
56538
56664
|
repositorySelectionUuid: uuid().nullish(),
|
|
@@ -56604,7 +56730,7 @@ var permissionSchema = _enum([
|
|
|
56604
56730
|
"platform.billing.write_off",
|
|
56605
56731
|
"billing.view",
|
|
56606
56732
|
"billing.profile.manage"
|
|
56607
|
-
]).describe("Every application permission. Permissions belong to roles in a scope; users receive roles. Company permissions are scoped to the company team, platform permissions to the reserved platform team. Nothing assigns a permission directly to a user.\n| |\n|---|\n| `operations.horizon.view` <br/>
|
|
56733
|
+
]).describe("Every application permission. Permissions belong to roles in a scope; users receive roles. Company permissions are scoped to the company team, platform permissions to the reserved platform team. Nothing assigns a permission directly to a user.\n| |\n|---|\n| `operations.horizon.view` <br/> |\n| `operations.impersonate` <br/> |\n| `platform.clients.view` <br/> |\n| `platform.clients.manage` <br/> |\n| `platform.alerts.manage` <br/> |\n| `hosting.diagnostics.view` <br/> |\n| `hosting.retention.approve` <br/> |\n| `platform.users.manage` <br/> Granting or removing a platform role. Deliberately granted to no role: it is a Super Admin act, reached through the platform bypass that already exists for that role. A grant that let a system admin promote another system admin would make the boundary it protects meaningless. |\n| `platform.accounts.close` <br/> |\n| `platform.companies.close` <br/> |\n| `hosting.deletion.execute` <br/> |\n| `hosting.vocabulary.manage` <br/> |\n| `hosting.seeds.manage` <br/> |\n| `hosting.storage.manage` <br/> |\n| `email.installation.adopt` <br/> |\n| `email.monitoring.manage` <br/> |\n| `platform.domains.ownership.attest` <br/> |\n| `platform.custd.ownership.attest` <br/> |\n| `platform.domains.ownership.transfer` <br/> |\n| `company.view` <br/> |\n| `company.update` <br/> |\n| `company.members.manage` <br/> |\n| `company.activity.view` <br/> |\n| `domain.view` <br/> |\n| `domain.manage` <br/> |\n| `dns.view` <br/> |\n| `dns.manage` <br/> |\n| `email.view` <br/> |\n| `email.manage` <br/> |\n| `hosting.tools.use` <br/> |\n| `hosting.access.view` <br/> |\n| `hosting.access.manage` <br/> |\n| `platform.billing.view` <br/> |\n| `platform.billing.manage` <br/> |\n| `platform.billing.write_off` <br/> |\n| `billing.view` <br/> |\n| `billing.profile.manage` <br/> |");
|
|
56608
56734
|
var companySummaryDataSchema = object({
|
|
56609
56735
|
slug: string(),
|
|
56610
56736
|
name: string(),
|
|
@@ -57132,17 +57258,17 @@ var createHostingApplicationRequestSchema = object({
|
|
|
57132
57258
|
runtimeVersion: string().max(16).nullish().describe("The PHP minor this new application is built and served on, or absent for its recipe's\ndefault. Which minors a recipe offers, and whether the images behind one are published,\nis refused by the catalogue and the tuning validation, by name."),
|
|
57133
57259
|
desiredGeneration: int().min(0)
|
|
57134
57260
|
}).describe("Adding one application to an environment that already exists.\n\n`type` is checked against the application types here, so a request that names the database\nserver or the cache is refused as an unknown application rather than travelling to a service\nthat would have to explain why infrastructure is not an application. Everything that compares\nthe new row with the environment's purchase, its existing rows or its volumes belongs to\n`HostingResourceService`, because a static rule cannot see the environment.\n\nResources are requests: what the application reserves from the environment's pool. Its limits may be left out,\nand then the runtime's default is recorded; one declared is honoured on the application's container. There is no\nreplica count, because an application in the shared Pod runs as one instance.\n\n`desiredGeneration` is required: adding an application changes the environment, so the\ncustomer states which version of it they reviewed, and a stale one is a conflict rather than\na second application.");
|
|
57135
|
-
var hostingRouteRewriteEnumSchema = _enum(["none", "strip"]).describe("How a path route presents its path to the application it routes to. `NONE` is the platform default: the application is served under the route's base path and is told it, because `BASE_PATH` is composed from the instance's canonical address. That is the right answer for an application that honours a base path, and it is what every route does until a customer chooses otherwise.
|
|
57261
|
+
var hostingRouteRewriteEnumSchema = _enum(["none", "strip"]).describe("How a path route presents its path to the application it routes to. `NONE` is the platform default: the application is served under the route's base path and is told it, because `BASE_PATH` is composed from the instance's canonical address. That is the right answer for an application that honours a base path, and it is what every route does until a customer chooses otherwise. `STRIP` removes the route's own path before the request reaches the application, for an application that cannot be configured with one: a route at `/learn` then answers as if it were served at the host root, so `/learn/foo` arrives as `/foo`. The instance is told no base path, because the paths it receives do not carry one. The customer chooses, because only they know whether their application can be configured for a base path. Neither answer is wrong, and the trade is stated where the choice is offered rather than guessed here: stripping is for an application that cannot be told, and telling it is what keeps its own absolute URLs, redirects and assets correct when it can.\n");
|
|
57136
57262
|
object({
|
|
57137
57263
|
sourceWorkloadUuid: uuid(),
|
|
57138
57264
|
targetWorkloadUuid: uuid(),
|
|
57139
57265
|
domainUuid: uuid().nullish(),
|
|
57140
57266
|
path: string().max(255),
|
|
57141
57267
|
canonical: boolean().optional(),
|
|
57142
|
-
rewrite: hostingRouteRewriteEnumSchema.optional().describe("How a path route presents its path to the application it routes to. `NONE` is the platform default: the application is served under the route's base path and is told it, because `BASE_PATH` is composed from the instance's canonical address. That is the right answer for an application that honours a base path, and it is what every route does until a customer chooses otherwise.
|
|
57268
|
+
rewrite: hostingRouteRewriteEnumSchema.optional().describe("How a path route presents its path to the application it routes to. `NONE` is the platform default: the application is served under the route's base path and is told it, because `BASE_PATH` is composed from the instance's canonical address. That is the right answer for an application that honours a base path, and it is what every route does until a customer chooses otherwise. `STRIP` removes the route's own path before the request reaches the application, for an application that cannot be configured with one: a route at `/learn` then answers as if it were served at the host root, so `/learn/foo` arrives as `/foo`. The instance is told no base path, because the paths it receives do not carry one. The customer chooses, because only they know whether their application can be configured for a base path. Neither answer is wrong, and the trade is stated where the choice is offered rather than guessed here: stripping is for an application that cannot be told, and telling it is what keeps its own absolute URLs, redirects and assets correct when it can.\n"),
|
|
57143
57269
|
desiredGeneration: int().min(1)
|
|
57144
57270
|
});
|
|
57145
|
-
var hostingCancellationDeletionTimingEnumSchema = _enum(["at-service-end", "now"]).describe("When the customer asked for the environment to be deleted. The choice is recorded on the cancellation episode rather than inferred from its dates, because \"service ends on the 3rd and deletion happens then\" and \"delete everything now\" are different promises even when the same day is involved.
|
|
57271
|
+
var hostingCancellationDeletionTimingEnumSchema = _enum(["at-service-end", "now"]).describe("When the customer asked for the environment to be deleted. The choice is recorded on the cancellation episode rather than inferred from its dates, because \"service ends on the 3rd and deletion happens then\" and \"delete everything now\" are different promises even when the same day is involved. A null timing is meaningful and deliberately legal: an episode recorded before this choice existed carries none, and those episodes keep the promise they were actually shown — deletion after their recoverable-until date rather than at service end.\n");
|
|
57146
57272
|
var hostingFinalCopyOrderEnumSchema = _enum(["best-effort", "stop-on-failure"]).describe("Whether the client's own copy has to succeed before their environment is deleted. `best-effort` is the default and reproduces what deletion already did: the copy is attempted, its outcome is recorded on the episode, and the deletion proceeds either way. `stop-on-failure` is the client's own instruction that the copy matters enough to keep the environment alive when it fails — it is their decision about their data, not someone else's approval, which is why the answer to a failed copy is to confirm the deletion again as best-effort rather than to find an operator.\n");
|
|
57147
57273
|
var createHostingCancellationRequestSchema = object({
|
|
57148
57274
|
reason: string().min(4).max(2e3),
|
|
@@ -57266,7 +57392,7 @@ var hostingVolumeEnumSchema = _enum([
|
|
|
57266
57392
|
"database-data",
|
|
57267
57393
|
"redis-data"
|
|
57268
57394
|
]);
|
|
57269
|
-
var hostingWorkloadServerModeEnumSchema = _enum(["shared", "dedicated"]).describe("Whether a workload's database server is shared with the rest of its engine, or bought for it alone. An environment runs ONE server per engine, and every database of that engine binds to it. That is the purchase's shape: one server's memory and CPU serve every application on the engine. A second same-engine server splits that purchase between two Pods that each must still clear the engine's own floor — measured on Home 2026-10-19, where such a split left an engine 512Mi and it was OOM-killed on every boot.
|
|
57395
|
+
var hostingWorkloadServerModeEnumSchema = _enum(["shared", "dedicated"]).describe("Whether a workload's database server is shared with the rest of its engine, or bought for it alone. An environment runs ONE server per engine, and every database of that engine binds to it. That is the purchase's shape: one server's memory and CPU serve every application on the engine. A second same-engine server splits that purchase between two Pods that each must still clear the engine's own floor — measured on Home 2026-10-19, where such a split left an engine 512Mi and it was OOM-killed on every boot. A second server is therefore a **client capability request** and never a side effect of declaring a workload. `DEDICATED` is that request: the workload pays its own floor out of the environment's budget, and the reconciler binds the databases to it by name rather than by engine. `SHARED` is every workload that did not ask. This is a named mode rather than a boolean because the same field may grow a third value (for example a replica-bearing server) without reinterpreting two call sites.\n| |\n|---|\n| `shared` <br/> The environment's existing server for this engine serves this workload's databases. |\n| `dedicated` <br/> The client asked for a server of this engine for this workload alone. |");
|
|
57270
57396
|
var createHostingEnvironmentRequestSchema = object({
|
|
57271
57397
|
certificateIssuer: hostingCertificateIssuerEnumSchema.optional(),
|
|
57272
57398
|
mode: hostingEnvironmentModeEnumSchema.optional(),
|
|
@@ -57298,7 +57424,7 @@ var createHostingEnvironmentRequestSchema = object({
|
|
|
57298
57424
|
name: string().max(100),
|
|
57299
57425
|
webServer: string().max(32).nullish(),
|
|
57300
57426
|
runtimeVersion: string().max(16).nullish(),
|
|
57301
|
-
serverMode: hostingWorkloadServerModeEnumSchema.optional().describe("Whether a workload's database server is shared with the rest of its engine, or bought for it alone. An environment runs ONE server per engine, and every database of that engine binds to it. That is the purchase's shape: one server's memory and CPU serve every application on the engine. A second same-engine server splits that purchase between two Pods that each must still clear the engine's own floor — measured on Home 2026-10-19, where such a split left an engine 512Mi and it was OOM-killed on every boot.
|
|
57427
|
+
serverMode: hostingWorkloadServerModeEnumSchema.optional().describe("Whether a workload's database server is shared with the rest of its engine, or bought for it alone. An environment runs ONE server per engine, and every database of that engine binds to it. That is the purchase's shape: one server's memory and CPU serve every application on the engine. A second same-engine server splits that purchase between two Pods that each must still clear the engine's own floor — measured on Home 2026-10-19, where such a split left an engine 512Mi and it was OOM-killed on every boot. A second server is therefore a **client capability request** and never a side effect of declaring a workload. `DEDICATED` is that request: the workload pays its own floor out of the environment's budget, and the reconciler binds the databases to it by name rather than by engine. `SHARED` is every workload that did not ask. This is a named mode rather than a boolean because the same field may grow a third value (for example a replica-bearing server) without reinterpreting two call sites.\n| |\n|---|\n| `shared` <br/> The environment's existing server for this engine serves this workload's databases. |\n| `dedicated` <br/> The client asked for a server of this engine for this workload alone. |"),
|
|
57302
57428
|
replicas: int().min(1),
|
|
57303
57429
|
resources: object({
|
|
57304
57430
|
cpuRequestMillicores: int().min(1),
|
|
@@ -57913,7 +58039,7 @@ var emailRecipientRouteStateDataSchema = object({
|
|
|
57913
58039
|
"local",
|
|
57914
58040
|
"foreign",
|
|
57915
58041
|
"unobserved"
|
|
57916
|
-
]).describe("What the last reconciliation observed for a claimed name's recipient route. The route decides where mail addressed to this name is delivered: this installation holds the mailboxes, or another provider named by the public MX receives it. A reader needs to tell \"we send
|
|
58042
|
+
]).describe("What the last reconciliation observed for a claimed name's recipient route. The route decides where mail addressed to this name is delivered: this installation holds the mailboxes, or another provider named by the public MX receives it. A reader needs to tell \"we send * their mail onward\" apart from \"we never looked\", which is why unobserved is a state rather than an absent value.\n| |\n|---|\n| `configured` <br/> The route is present and carries this platform's ownership marker. |\n| `adopted` <br/> The route was written outside this platform but points at the proved public MX, so it was adopted. |\n| `external` <br/> Another provider receives this name's mail and this installation holds no route for it. |\n| `local` <br/> No route, and the public MX is this installation: recipients are delivered locally. |\n| `foreign` <br/> A route exists that this platform neither owns nor can adopt. It is never overwritten. |\n| `unobserved` <br/> No reconciliation has recorded an observation yet. |").describe("What the last reconciliation observed for a claimed name's recipient route. The route decides where mail addressed to this name is delivered: this installation holds the mailboxes, or another provider named by the public MX receives it. A reader needs to tell \"we send * their mail onward\" apart from \"we never looked\", which is why unobserved is a state rather than an absent value.\n| |\n|---|\n| `configured` <br/> The route is present and carries this platform's ownership marker. |\n| `adopted` <br/> The route was written outside this platform but points at the proved public MX, so it was adopted. |\n| `external` <br/> Another provider receives this name's mail and this installation holds no route for it. |\n| `local` <br/> No route, and the public MX is this installation: recipients are delivered locally. |\n| `foreign` <br/> A route exists that this platform neither owns nor can adopt. It is never overwritten. |\n| `unobserved` <br/> No reconciliation has recorded an observation yet. |"),
|
|
57917
58043
|
target: string().nullable(),
|
|
57918
58044
|
observedAt: string()
|
|
57919
58045
|
});
|
|
@@ -58290,12 +58416,40 @@ var hostingAccessConnectionDataSchema = object({
|
|
|
58290
58416
|
fingerprintCommand: string().nullable(),
|
|
58291
58417
|
note: string()
|
|
58292
58418
|
});
|
|
58419
|
+
var hostingFailureCauseEnumSchema = _enum([
|
|
58420
|
+
"source-not-reachable",
|
|
58421
|
+
"commit-not-found",
|
|
58422
|
+
"recipe-refusal",
|
|
58423
|
+
"build-timeout",
|
|
58424
|
+
"build-command-failed",
|
|
58425
|
+
"worker-never-reported",
|
|
58426
|
+
"image-unavailable",
|
|
58427
|
+
"dependency-unsatisfied",
|
|
58428
|
+
"release-task-failed",
|
|
58429
|
+
"validation-refusal",
|
|
58430
|
+
"bundle-refused",
|
|
58431
|
+
"source-refused",
|
|
58432
|
+
"rebuild-required",
|
|
58433
|
+
"kubernetes-refusal",
|
|
58434
|
+
"resource-conflict",
|
|
58435
|
+
"transient-transport",
|
|
58436
|
+
"unclassified"
|
|
58437
|
+
]).describe("Why a build or a release stopped, in a closed vocabulary a client can act on. The raw reason a job records is written for whoever debugs the platform: it names namespaces, objects and exception text. This is the other half — a fixed set of causes, each with a sentence a client can read and one next action — so \"it failed\" becomes \"your source could not be reached; check the token\". A cause the platform has not classified yet says exactly that, rather than guessing at one.\n");
|
|
58438
|
+
var hostingFailureOwnerEnumSchema = _enum(["client", "platform"]).describe("Who has to act on a failure. This is what lets a surface stop inviting a retry that cannot succeed: when the platform owns the cause, the client is told so and the retry affordance is withheld rather than offered and then refused.\n");
|
|
58439
|
+
var hostingFailureExplanationDataSchema = object({
|
|
58440
|
+
cause: hostingFailureCauseEnumSchema.describe("Why a build or a release stopped, in a closed vocabulary a client can act on. The raw reason a job records is written for whoever debugs the platform: it names namespaces, objects and exception text. This is the other half — a fixed set of causes, each with a sentence a client can read and one next action — so \"it failed\" becomes \"your source could not be reached; check the token\". A cause the platform has not classified yet says exactly that, rather than guessing at one.\n"),
|
|
58441
|
+
message: string(),
|
|
58442
|
+
owner: hostingFailureOwnerEnumSchema.describe("Who has to act on a failure. This is what lets a surface stop inviting a retry that cannot succeed: when the platform owns the cause, the client is told so and the retry affordance is withheld rather than offered and then refused.\n"),
|
|
58443
|
+
nextAction: string().nullable(),
|
|
58444
|
+
retryable: boolean()
|
|
58445
|
+
});
|
|
58293
58446
|
var hostingEnvironmentStatusDataSchema = object({
|
|
58294
58447
|
status: string(),
|
|
58295
58448
|
generation: int(),
|
|
58296
58449
|
appliedGeneration: int(),
|
|
58297
58450
|
message: string(),
|
|
58298
|
-
observedAt: string().nullable()
|
|
58451
|
+
observedAt: string().nullable(),
|
|
58452
|
+
explanation: union([hostingFailureExplanationDataSchema, _null()])
|
|
58299
58453
|
});
|
|
58300
58454
|
var hostingDeploymentIdentityAccessDataSchema = object({
|
|
58301
58455
|
siteUserUuid: string(),
|
|
@@ -58995,11 +59149,11 @@ var hostingRestoreCheckOutcomeEnumSchema = _enum([
|
|
|
58995
59149
|
"refused",
|
|
58996
59150
|
"unavailable",
|
|
58997
59151
|
"deferred"
|
|
58998
|
-
]).describe("What one restore-intake check found. Three values, because \"we could not measure it\" is not the same statement as \"it does not fit\": an unmeasured figure is a refusal with a different fix, and folding it into `refused` would train an operator to read a missing measurement as a capacity problem. A restore is admitted only when every check is `ok`.
|
|
59152
|
+
]).describe("What one restore-intake check found. Three values, because \"we could not measure it\" is not the same statement as \"it does not fit\": an unmeasured figure is a refusal with a different fix, and folding it into `refused` would train an operator to read a missing measurement as a capacity problem. A restore is admitted only when every check is `ok`. Deliberately not persisted. This is a reading taken on demand before a destructive write, not desired state, so there is no table and no generated enum behind it.\n| |\n|---|\n| `ok` <br/> The measured figure fits the named limit. |\n| `refused` <br/> A measured figure does not fit, or a required condition is false. |\n| `unavailable` <br/> The figure needed to decide is absent. Automation stops rather than assuming a value; staff measure or rehearse and submit the number. |\n| `deferred` <br/> The figure is not readable at review time and is measured at the destructive boundary instead. It does not block the review, because the review is not allowed to refuse an operation for a figure it cannot yet read — and it never accepts a caller's figure for one either: the operation runs the same check with the measurement before the writer Job may be applied. |");
|
|
58999
59153
|
var hostingRestoreIntakeCheckDataSchema = object({
|
|
59000
59154
|
key: string(),
|
|
59001
59155
|
label: string(),
|
|
59002
|
-
outcome: hostingRestoreCheckOutcomeEnumSchema.describe("What one restore-intake check found. Three values, because \"we could not measure it\" is not the same statement as \"it does not fit\": an unmeasured figure is a refusal with a different fix, and folding it into `refused` would train an operator to read a missing measurement as a capacity problem. A restore is admitted only when every check is `ok`.
|
|
59156
|
+
outcome: hostingRestoreCheckOutcomeEnumSchema.describe("What one restore-intake check found. Three values, because \"we could not measure it\" is not the same statement as \"it does not fit\": an unmeasured figure is a refusal with a different fix, and folding it into `refused` would train an operator to read a missing measurement as a capacity problem. A restore is admitted only when every check is `ok`. Deliberately not persisted. This is a reading taken on demand before a destructive write, not desired state, so there is no table and no generated enum behind it.\n| |\n|---|\n| `ok` <br/> The measured figure fits the named limit. |\n| `refused` <br/> A measured figure does not fit, or a required condition is false. |\n| `unavailable` <br/> The figure needed to decide is absent. Automation stops rather than assuming a value; staff measure or rehearse and submit the number. |\n| `deferred` <br/> The figure is not readable at review time and is measured at the destructive boundary instead. It does not block the review, because the review is not allowed to refuse an operation for a figure it cannot yet read — and it never accepts a caller's figure for one either: the operation runs the same check with the measurement before the writer Job may be applied. |"),
|
|
59003
59157
|
measured: string(),
|
|
59004
59158
|
required: string(),
|
|
59005
59159
|
detail: string()
|
|
@@ -59054,19 +59208,38 @@ var hostingApplicationRecoveryReviewDataSchema = object({
|
|
|
59054
59208
|
blockedReason: string().nullable(),
|
|
59055
59209
|
recovery: union([hostingApplicationRecoveryDataSchema, _null()])
|
|
59056
59210
|
});
|
|
59211
|
+
var hostingApplicationRedLineDecisionDataSchema = object({
|
|
59212
|
+
rung: _enum([
|
|
59213
|
+
"healthy",
|
|
59214
|
+
"unmeasured",
|
|
59215
|
+
"warn",
|
|
59216
|
+
"throttle",
|
|
59217
|
+
"memory",
|
|
59218
|
+
"oom"
|
|
59219
|
+
]).describe("The rung one APPLICATION sits on in the red-line ladder. The vocabulary is closed for the same reason {@see HostingNoisyNeighbourRungEnum}'s is: the ladder escalates in a fixed order, every consumer has to be able to switch on the rung exhaustively, and an unrecognised rung would be a bug rather than a state. The order is the escalation order, and it is the order the responses are meant to be taken in: 1. `healthy` — every signal that could be measured is below its warn line. 2. `unmeasured` — nothing could be measured, so no red line was established. This is NOT an escalation: it sits above `healthy` only because an operator reading the ranked list should see the applications the ladder cannot speak for, rather than a clean bill of health nobody measured. 3. `warn` — a signal reached its warn line and nothing more is true of the application yet. 4. `throttle` — the kernel held the application back for a material share of its CPU periods. 5. `memory` — the working set is at the red line under the declared memory limit, one step before the kernel enforces it. 6. `oom` — the kernel already stopped it for exceeding that limit. Worst, because this is an outage rather than a slowdown, and because \"your site went down\" and \"your site exceeded 512 MiB\" are different support tickets.\n").describe("The rung one APPLICATION sits on in the red-line ladder. The vocabulary is closed for the same reason {@see HostingNoisyNeighbourRungEnum}'s is: the ladder escalates in a fixed order, every consumer has to be able to switch on the rung exhaustively, and an unrecognised rung would be a bug rather than a state. The order is the escalation order, and it is the order the responses are meant to be taken in: 1. `healthy` — every signal that could be measured is below its warn line. 2. `unmeasured` — nothing could be measured, so no red line was established. This is NOT an escalation: it sits above `healthy` only because an operator reading the ranked list should see the applications the ladder cannot speak for, rather than a clean bill of health nobody measured. 3. `warn` — a signal reached its warn line and nothing more is true of the application yet. 4. `throttle` — the kernel held the application back for a material share of its CPU periods. 5. `memory` — the working set is at the red line under the declared memory limit, one step before the kernel enforces it. 6. `oom` — the kernel already stopped it for exceeding that limit. Worst, because this is an outage rather than a slowdown, and because \"your site went down\" and \"your site exceeded 512 MiB\" are different support tickets.\n"),
|
|
59220
|
+
reason: string(),
|
|
59221
|
+
recommendation: string()
|
|
59222
|
+
});
|
|
59223
|
+
var hostingContainerIssueStateEnumSchema = _enum([
|
|
59224
|
+
"out-of-memory",
|
|
59225
|
+
"crash-loop",
|
|
59226
|
+
"image-unavailable",
|
|
59227
|
+
"start-refused",
|
|
59228
|
+
"health-check-failing",
|
|
59229
|
+
"not-ready"
|
|
59230
|
+
]).describe("Why one of an application's containers is not ready, in a closed vocabulary a client can act on. The cluster's own reasons are an open set written for whoever operates it. This is the fixed set a client reads: each state has one sentence and, when the client can change the outcome, one next action. It is observed from the cluster on demand and never stored, so it is a handwritten enum rather than a catalog. A reason the platform has not classified says exactly that instead of guessing at a cause.\n");
|
|
59231
|
+
var hostingContainerIssueDataSchema = object({
|
|
59232
|
+
container: string(),
|
|
59233
|
+
process: string().nullable(),
|
|
59234
|
+
state: hostingContainerIssueStateEnumSchema.describe("Why one of an application's containers is not ready, in a closed vocabulary a client can act on. The cluster's own reasons are an open set written for whoever operates it. This is the fixed set a client reads: each state has one sentence and, when the client can change the outcome, one next action. It is observed from the cluster on demand and never stored, so it is a handwritten enum rather than a catalog. A reason the platform has not classified says exactly that instead of guessing at a cause.\n"),
|
|
59235
|
+
restartCount: int(),
|
|
59236
|
+
lastExitCode: int().nullable(),
|
|
59237
|
+
message: string(),
|
|
59238
|
+
nextAction: string().nullable(),
|
|
59239
|
+
owner: hostingFailureOwnerEnumSchema.describe("Who has to act on a failure. This is what lets a surface stop inviting a retry that cannot succeed: when the platform owns the cause, the client is told so and the retry affordance is withheld rather than offered and then refused.\n")
|
|
59240
|
+
});
|
|
59057
59241
|
object({
|
|
59058
|
-
decision:
|
|
59059
|
-
rung: _enum([
|
|
59060
|
-
"healthy",
|
|
59061
|
-
"unmeasured",
|
|
59062
|
-
"warn",
|
|
59063
|
-
"throttle",
|
|
59064
|
-
"memory",
|
|
59065
|
-
"oom"
|
|
59066
|
-
]).describe("The rung one APPLICATION sits on in the red-line ladder. The vocabulary is closed for the same reason {@see HostingNoisyNeighbourRungEnum}'s is: the ladder escalates in a fixed order, every consumer has to be able to switch on the rung exhaustively, and an unrecognised rung would be a bug rather than a state. The order is the escalation order, and it is the order the responses are meant to be taken in: 1. `healthy` — every signal that could be measured is below its warn line. 2. `unmeasured` — nothing could be measured, so no red line was established. This is NOT an escalation: it sits above `healthy` only because an operator reading the ranked list should see the applications the ladder cannot speak for, rather than a clean bill of health nobody measured. 3. `warn` — a signal reached its warn line and nothing more is true of the application yet. 4. `throttle` — the kernel held the application back for a material share of its CPU periods. 5. `memory` — the working set is at the red line under the declared memory limit, one step before the kernel enforces it. 6. `oom` — the kernel already stopped it for exceeding that limit. Worst, because this is an outage rather than a slowdown, and because \"your site went down\" and \"your site exceeded 512 MiB\" are different support tickets.\n").describe("The rung one APPLICATION sits on in the red-line ladder. The vocabulary is closed for the same reason {@see HostingNoisyNeighbourRungEnum}'s is: the ladder escalates in a fixed order, every consumer has to be able to switch on the rung exhaustively, and an unrecognised rung would be a bug rather than a state. The order is the escalation order, and it is the order the responses are meant to be taken in: 1. `healthy` — every signal that could be measured is below its warn line. 2. `unmeasured` — nothing could be measured, so no red line was established. This is NOT an escalation: it sits above `healthy` only because an operator reading the ranked list should see the applications the ladder cannot speak for, rather than a clean bill of health nobody measured. 3. `warn` — a signal reached its warn line and nothing more is true of the application yet. 4. `throttle` — the kernel held the application back for a material share of its CPU periods. 5. `memory` — the working set is at the red line under the declared memory limit, one step before the kernel enforces it. 6. `oom` — the kernel already stopped it for exceeding that limit. Worst, because this is an outage rather than a slowdown, and because \"your site went down\" and \"your site exceeded 512 MiB\" are different support tickets.\n"),
|
|
59067
|
-
reason: string(),
|
|
59068
|
-
recommendation: string()
|
|
59069
|
-
}),
|
|
59242
|
+
decision: hostingApplicationRedLineDecisionDataSchema,
|
|
59070
59243
|
signals: object({
|
|
59071
59244
|
tenant: string(),
|
|
59072
59245
|
environment: string(),
|
|
@@ -59077,7 +59250,8 @@ object({
|
|
|
59077
59250
|
oomKills: int().nullable(),
|
|
59078
59251
|
cpuCommittedRatio: number(),
|
|
59079
59252
|
memoryCommittedRatio: number(),
|
|
59080
|
-
unmeasured: array(string())
|
|
59253
|
+
unmeasured: array(string()),
|
|
59254
|
+
containerIssues: array(hostingContainerIssueDataSchema).nullable()
|
|
59081
59255
|
})
|
|
59082
59256
|
});
|
|
59083
59257
|
var hostingApplicationRemovalDataSchema = object({
|
|
@@ -59120,7 +59294,7 @@ var hostingApplicationRouteDataSchema = object({
|
|
|
59120
59294
|
path: string(),
|
|
59121
59295
|
url: string().nullable(),
|
|
59122
59296
|
canonical: boolean(),
|
|
59123
|
-
rewrite: hostingRouteRewriteEnumSchema.describe("How a path route presents its path to the application it routes to. `NONE` is the platform default: the application is served under the route's base path and is told it, because `BASE_PATH` is composed from the instance's canonical address. That is the right answer for an application that honours a base path, and it is what every route does until a customer chooses otherwise.
|
|
59297
|
+
rewrite: hostingRouteRewriteEnumSchema.describe("How a path route presents its path to the application it routes to. `NONE` is the platform default: the application is served under the route's base path and is told it, because `BASE_PATH` is composed from the instance's canonical address. That is the right answer for an application that honours a base path, and it is what every route does until a customer chooses otherwise. `STRIP` removes the route's own path before the request reaches the application, for an application that cannot be configured with one: a route at `/learn` then answers as if it were served at the host root, so `/learn/foo` arrives as `/foo`. The instance is told no base path, because the paths it receives do not carry one. The customer chooses, because only they know whether their application can be configured for a base path. Neither answer is wrong, and the trade is stated where the choice is offered rather than guessed here: stripping is for an application that cannot be told, and telling it is what keeps its own absolute URLs, redirects and assets correct when it can.\n")
|
|
59124
59298
|
});
|
|
59125
59299
|
object({
|
|
59126
59300
|
environmentUuid: string(),
|
|
@@ -59136,7 +59310,7 @@ var hostingAutoDeployVerdictDataSchema = object({
|
|
|
59136
59310
|
"stale",
|
|
59137
59311
|
"no_event_revision",
|
|
59138
59312
|
"undecidable"
|
|
59139
|
-
]).describe("What one update event is, judged against what this application already serves. A delivery is not an instruction. It can be redelivered, and it can arrive after a newer one was already applied, so the platform has to answer \"is this event about a revision we have not applied
|
|
59313
|
+
]).describe("What one update event is, judged against what this application already serves. A delivery is not an instruction. It can be redelivered, and it can arrive after a newer one was already applied, so the platform has to answer \"is this event about a revision we have not applied * yet?\" before anything is built. Each answer has its own name and its own sentence, because \"duplicate\" and \"stale\" are different facts with different next steps: a duplicate says the event names the release that is serving, and a stale event says the event names a revision the platform has already moved past. Nothing is persisted from this enum. It is a decision read at the moment it is asked for, which is why it is a hand-written enum beside the generated catalog enums rather than a type table.\n| |\n|---|\n| `forward` <br/> The event names a revision this application does not serve, and nothing shows the platform moved past it. |\n| `duplicate` <br/> The event names exactly the revision the serving release was built from: the platform already applied it. |\n| `stale` <br/> The event names a revision behind the one this application already serves, so applying it would go backwards. |\n| `no_event_revision` <br/> The delivery carries no commit, so there is nothing to place against the served revision. |\n| `undecidable` <br/> The two revisions could not be ordered against each other. This is not a stale event and it is not a forward one. The repository named no order between the delivered commit and the one this application serves, so the platform cannot prove that applying it would move forward — and it will not apply a revision it cannot place. The delivery is named as undecidable rather than refused under another name, so a reader can tell \"we could not tell\" from \"we know it is behind\". |").describe("What one update event is, judged against what this application already serves. A delivery is not an instruction. It can be redelivered, and it can arrive after a newer one was already applied, so the platform has to answer \"is this event about a revision we have not applied * yet?\" before anything is built. Each answer has its own name and its own sentence, because \"duplicate\" and \"stale\" are different facts with different next steps: a duplicate says the event names the release that is serving, and a stale event says the event names a revision the platform has already moved past. Nothing is persisted from this enum. It is a decision read at the moment it is asked for, which is why it is a hand-written enum beside the generated catalog enums rather than a type table.\n| |\n|---|\n| `forward` <br/> The event names a revision this application does not serve, and nothing shows the platform moved past it. |\n| `duplicate` <br/> The event names exactly the revision the serving release was built from: the platform already applied it. |\n| `stale` <br/> The event names a revision behind the one this application already serves, so applying it would go backwards. |\n| `no_event_revision` <br/> The delivery carries no commit, so there is nothing to place against the served revision. |\n| `undecidable` <br/> The two revisions could not be ordered against each other. This is not a stale event and it is not a forward one. The repository named no order between the delivered commit and the one this application serves, so the platform cannot prove that applying it would move forward — and it will not apply a revision it cannot place. The delivery is named as undecidable rather than refused under another name, so a reader can tell \"we could not tell\" from \"we know it is behind\". |"),
|
|
59140
59314
|
eventRevision: string().nullable().describe("The revision the push named, abbreviated, or null when the delivery carried none."),
|
|
59141
59315
|
deployedRevision: string().nullable().describe("The revision serving when the decision was drawn, abbreviated, or null when none served."),
|
|
59142
59316
|
explanation: string().describe("What the outcome means for this push, in one sentence."),
|
|
@@ -59208,30 +59382,6 @@ var hostingBudgetMemberKindEnumSchema = _enum([
|
|
|
59208
59382
|
"application",
|
|
59209
59383
|
"database"
|
|
59210
59384
|
]).describe("What one row of an environment's budget view reserves for: the shared Pod, an application with Pods of its own, or a database server the purchase funds. Closed, because the view lists exactly these three kinds of reservation.\n");
|
|
59211
|
-
var hostingFailureCauseEnumSchema = _enum([
|
|
59212
|
-
"source-not-reachable",
|
|
59213
|
-
"commit-not-found",
|
|
59214
|
-
"recipe-refusal",
|
|
59215
|
-
"build-timeout",
|
|
59216
|
-
"build-command-failed",
|
|
59217
|
-
"worker-never-reported",
|
|
59218
|
-
"image-unavailable",
|
|
59219
|
-
"dependency-unsatisfied",
|
|
59220
|
-
"release-task-failed",
|
|
59221
|
-
"validation-refusal",
|
|
59222
|
-
"kubernetes-refusal",
|
|
59223
|
-
"resource-conflict",
|
|
59224
|
-
"transient-transport",
|
|
59225
|
-
"unclassified"
|
|
59226
|
-
]).describe("Why a build or a release stopped, in a closed vocabulary a client can act on. The raw reason a job records is written for whoever debugs the platform: it names namespaces, objects and exception text. This is the other half — a fixed set of causes, each with a sentence a client can read and one next action — so \"it failed\" becomes \"your source could not be reached; check the token\". A cause the platform has not classified yet says exactly that, rather than guessing at one.\n");
|
|
59227
|
-
var hostingFailureOwnerEnumSchema = _enum(["client", "platform"]).describe("Who has to act on a failure. This is what lets a surface stop inviting a retry that cannot succeed: when the platform owns the cause, the client is told so and the retry affordance is withheld rather than offered and then refused.\n");
|
|
59228
|
-
var hostingFailureExplanationDataSchema = object({
|
|
59229
|
-
cause: hostingFailureCauseEnumSchema.describe("Why a build or a release stopped, in a closed vocabulary a client can act on. The raw reason a job records is written for whoever debugs the platform: it names namespaces, objects and exception text. This is the other half — a fixed set of causes, each with a sentence a client can read and one next action — so \"it failed\" becomes \"your source could not be reached; check the token\". A cause the platform has not classified yet says exactly that, rather than guessing at one.\n"),
|
|
59230
|
-
message: string(),
|
|
59231
|
-
owner: hostingFailureOwnerEnumSchema.describe("Who has to act on a failure. This is what lets a surface stop inviting a retry that cannot succeed: when the platform owns the cause, the client is told so and the retry affordance is withheld rather than offered and then refused.\n"),
|
|
59232
|
-
nextAction: string().nullable(),
|
|
59233
|
-
retryable: boolean()
|
|
59234
|
-
});
|
|
59235
59385
|
var hostingBuildDeployModeEnumSchema = _enum(["candidate", "deploy-when-built"]).describe("What a person asked to happen once their build succeeds. `candidate` leaves the release for a deliberate Deploy. `deploy-when-built` is a recorded intent: the backend promotes and deploys the release as the person who asked, so leaving the page during the build changes nothing. It is the person's own request, separate from a branch push's automatic-deployment consent, so an update pause (which governs pushes) does not refuse it.\n");
|
|
59236
59386
|
var hostingBuildDataSchema = object({
|
|
59237
59387
|
uuid: string(),
|
|
@@ -59304,13 +59454,13 @@ var hostingCacheRuleActionEnumSchema = _enum([
|
|
|
59304
59454
|
"respect_origin",
|
|
59305
59455
|
"public_assets",
|
|
59306
59456
|
"public_pages"
|
|
59307
|
-
]).describe("What one ordered cache rule does to a matching request. `RESPECT_ORIGIN` bounds the origin's own policy and never lengthens it. `PUBLIC_ASSETS` may supply a missing policy for an approved static response type; it also declares the path public enough that a visitor's cookie is ignored. `PUBLIC_PAGES` may supply a missing policy for an anonymous HTML page, and deliberately does NOT ignore a cookie — a cookie is exactly how WordPress marks a visitor who has signed in, added to a cart or started a session. `BYPASS` sends the request to the origin untouched.
|
|
59308
|
-
var hostingCacheRuleMatchEnumSchema = _enum(["exact", "prefix"]).describe("How a rule's path is matched against the request path. `EXACT` matches one path and nothing below it. `PREFIX` matches the path at a segment boundary, so `/media` matches `/media/x.css` but never `/mediaeval`. The rule always matches the path alone; the query string and Host stay in the cache key.
|
|
59457
|
+
]).describe("What one ordered cache rule does to a matching request. `RESPECT_ORIGIN` bounds the origin's own policy and never lengthens it. `PUBLIC_ASSETS` may supply a missing policy for an approved static response type; it also declares the path public enough that a visitor's cookie is ignored. `PUBLIC_PAGES` may supply a missing policy for an anonymous HTML page, and deliberately does NOT ignore a cookie — a cookie is exactly how WordPress marks a visitor who has signed in, added to a cart or started a session. `BYPASS` sends the request to the origin untouched. Two separate questions are asked below rather than one, because conflating them is how a page cache starts serving one visitor's session to another. The case names are the stored values, so a rule's action is a declared value rather than a string some caller has to remember.\n");
|
|
59458
|
+
var hostingCacheRuleMatchEnumSchema = _enum(["exact", "prefix"]).describe("How a rule's path is matched against the request path. `EXACT` matches one path and nothing below it. `PREFIX` matches the path at a segment boundary, so `/media` matches `/media/x.css` but never `/mediaeval`. The rule always matches the path alone; the query string and Host stay in the cache key. There is deliberately no regular-expression case: a customer expression language is not a boundary we can validate, and the two shapes above cover the reviewed use.\n");
|
|
59309
59459
|
var hostingCacheRuleDataSchema = object({
|
|
59310
59460
|
label: string(),
|
|
59311
|
-
match: hostingCacheRuleMatchEnumSchema.describe("How a rule's path is matched against the request path. `EXACT` matches one path and nothing below it. `PREFIX` matches the path at a segment boundary, so `/media` matches `/media/x.css` but never `/mediaeval`. The rule always matches the path alone; the query string and Host stay in the cache key.
|
|
59461
|
+
match: hostingCacheRuleMatchEnumSchema.describe("How a rule's path is matched against the request path. `EXACT` matches one path and nothing below it. `PREFIX` matches the path at a segment boundary, so `/media` matches `/media/x.css` but never `/mediaeval`. The rule always matches the path alone; the query string and Host stay in the cache key. There is deliberately no regular-expression case: a customer expression language is not a boundary we can validate, and the two shapes above cover the reviewed use.\n"),
|
|
59312
59462
|
path: string(),
|
|
59313
|
-
action: hostingCacheRuleActionEnumSchema.describe("What one ordered cache rule does to a matching request. `RESPECT_ORIGIN` bounds the origin's own policy and never lengthens it. `PUBLIC_ASSETS` may supply a missing policy for an approved static response type; it also declares the path public enough that a visitor's cookie is ignored. `PUBLIC_PAGES` may supply a missing policy for an anonymous HTML page, and deliberately does NOT ignore a cookie — a cookie is exactly how WordPress marks a visitor who has signed in, added to a cart or started a session. `BYPASS` sends the request to the origin untouched.
|
|
59463
|
+
action: hostingCacheRuleActionEnumSchema.describe("What one ordered cache rule does to a matching request. `RESPECT_ORIGIN` bounds the origin's own policy and never lengthens it. `PUBLIC_ASSETS` may supply a missing policy for an approved static response type; it also declares the path public enough that a visitor's cookie is ignored. `PUBLIC_PAGES` may supply a missing policy for an anonymous HTML page, and deliberately does NOT ignore a cookie — a cookie is exactly how WordPress marks a visitor who has signed in, added to a cart or started a session. `BYPASS` sends the request to the origin untouched. Two separate questions are asked below rather than one, because conflating them is how a page cache starts serving one visitor's session to another. The case names are the stored values, so a rule's action is a declared value rather than a string some caller has to remember.\n"),
|
|
59314
59464
|
enabled: boolean(),
|
|
59315
59465
|
hostname: string().nullable(),
|
|
59316
59466
|
freshSeconds: int(),
|
|
@@ -59343,7 +59493,7 @@ var hostingRestorePointStateEnumSchema = _enum([
|
|
|
59343
59493
|
"observed",
|
|
59344
59494
|
"none_found",
|
|
59345
59495
|
"unconfirmed"
|
|
59346
|
-
]).describe("What the platform can honestly say about a restore point behind a cancellation review. Two stored facts answer this: whether a successful read found a restore point (`restore_point_observed_at`), and when the platform last succeeded in looking (`restore_point_checked_at`). Neither column alone separates \"there is no copy\" from \"we never
|
|
59496
|
+
]).describe("What the platform can honestly say about a restore point behind a cancellation review. Two stored facts answer this: whether a successful read found a restore point (`restore_point_observed_at`), and when the platform last succeeded in looking (`restore_point_checked_at`). Neither column alone separates \"there is no copy\" from \"we never * managed to look\", and that difference is the whole warning a deletion confirmation carries. `observed` means a completed backup run was seen, which also proves a read succeeded. `none_found` means the platform read successfully and no track reported a completed run; it is the only case that may say a restore point was not found, and it is dated by the check because a later pass can still observe one. `unconfirmed` means no successful read has happened — no pass has run for this environment yet, or the pass could not read the cluster or the object store — and it may never say a copy is absent.\n");
|
|
59347
59497
|
var hostingCancellationTargetDataSchema = object({
|
|
59348
59498
|
workloadUuid: string(),
|
|
59349
59499
|
name: string(),
|
|
@@ -59377,7 +59527,7 @@ var hostingCancellationReviewDataSchema = object({
|
|
|
59377
59527
|
namespace: string(),
|
|
59378
59528
|
serviceEndsAt: string(),
|
|
59379
59529
|
dataRecoverableUntil: string(),
|
|
59380
|
-
restorePointState: hostingRestorePointStateEnumSchema.describe("What the platform can honestly say about a restore point behind a cancellation review. Two stored facts answer this: whether a successful read found a restore point (`restore_point_observed_at`), and when the platform last succeeded in looking (`restore_point_checked_at`). Neither column alone separates \"there is no copy\" from \"we never
|
|
59530
|
+
restorePointState: hostingRestorePointStateEnumSchema.describe("What the platform can honestly say about a restore point behind a cancellation review. Two stored facts answer this: whether a successful read found a restore point (`restore_point_observed_at`), and when the platform last succeeded in looking (`restore_point_checked_at`). Neither column alone separates \"there is no copy\" from \"we never * managed to look\", and that difference is the whole warning a deletion confirmation carries. `observed` means a completed backup run was seen, which also proves a read succeeded. `none_found` means the platform read successfully and no track reported a completed run; it is the only case that may say a restore point was not found, and it is dated by the check because a later pass can still observe one. `unconfirmed` means no successful read has happened — no pass has run for this environment yet, or the pass could not read the cluster or the object store — and it may never say a copy is absent.\n"),
|
|
59381
59531
|
restorePointObservedAt: string().nullable(),
|
|
59382
59532
|
restorePointCheckedAt: string().nullable(),
|
|
59383
59533
|
earliestServiceEndsAt: string(),
|
|
@@ -59683,7 +59833,7 @@ var hostingConfigurationRouteDataSchema = object({
|
|
|
59683
59833
|
source: string(),
|
|
59684
59834
|
target: string(),
|
|
59685
59835
|
path: string(),
|
|
59686
|
-
rewrite: hostingRouteRewriteEnumSchema.describe("How a path route presents its path to the application it routes to. `NONE` is the platform default: the application is served under the route's base path and is told it, because `BASE_PATH` is composed from the instance's canonical address. That is the right answer for an application that honours a base path, and it is what every route does until a customer chooses otherwise.
|
|
59836
|
+
rewrite: hostingRouteRewriteEnumSchema.describe("How a path route presents its path to the application it routes to. `NONE` is the platform default: the application is served under the route's base path and is told it, because `BASE_PATH` is composed from the instance's canonical address. That is the right answer for an application that honours a base path, and it is what every route does until a customer chooses otherwise. `STRIP` removes the route's own path before the request reaches the application, for an application that cannot be configured with one: a route at `/learn` then answers as if it were served at the host root, so `/learn/foo` arrives as `/foo`. The instance is told no base path, because the paths it receives do not carry one. The customer chooses, because only they know whether their application can be configured for a base path. Neither answer is wrong, and the trade is stated where the choice is offered rather than guessed here: stripping is for an application that cannot be told, and telling it is what keeps its own absolute URLs, redirects and assets correct when it can.\n"),
|
|
59687
59837
|
canonical: boolean()
|
|
59688
59838
|
});
|
|
59689
59839
|
var hostingConfigurationDataSchema = object({
|
|
@@ -60017,7 +60167,7 @@ var hostingDatabaseDataMigrationPeerBindingsDataSchema = object({ bindings: arra
|
|
|
60017
60167
|
canonicalClaimUid: string().nullable(),
|
|
60018
60168
|
destinationControllerUid: string().nullable()
|
|
60019
60169
|
})) });
|
|
60020
|
-
var hostingVolumeAccessModeEnumSchema = _enum(["ReadWriteOnce", "ReadWriteMany"]).describe("How many nodes may mount one claim at once. The values are Kubernetes' own `accessModes` strings, because this is recorded as the fact a PersistentVolumeClaim is rendered from rather than as a platform vocabulary that has to be translated at the one place it is used.
|
|
60170
|
+
var hostingVolumeAccessModeEnumSchema = _enum(["ReadWriteOnce", "ReadWriteMany"]).describe("How many nodes may mount one claim at once. The values are Kubernetes' own `accessModes` strings, because this is recorded as the fact a PersistentVolumeClaim is rendered from rather than as a platform vocabulary that has to be translated at the one place it is used. `READ_WRITE_MANY` is a shared filesystem: consumers on different nodes may mount the claim. `READ_WRITE_ONCE` is a single-node attachment: the volume attaches to ONE node, every consumer has to be on that node, and the measured payoff is that many-small-file work stops crossing the network. A claim's access mode is immutable in Kubernetes. Once a volume is recorded as `READ_WRITE_ONCE` the environment can never serve its files from more than one node, which is why the layout that may use it is decided when the claim is created and why a later layout change is refused rather than applied (see `HostingEnvironmentService::optOutOfSharedEnvironmentPod()`).\n");
|
|
60021
60171
|
var hostingStorageClassDataSchema = object({
|
|
60022
60172
|
uuid: string(),
|
|
60023
60173
|
clusterUuid: string(),
|
|
@@ -60064,7 +60214,7 @@ var hostingDatabaseDataMigrationReviewDataSchema = object({
|
|
|
60064
60214
|
sourcePvName: string(),
|
|
60065
60215
|
sourcePvUid: string(),
|
|
60066
60216
|
sourceProvisioner: string(),
|
|
60067
|
-
sourceAccessMode: hostingVolumeAccessModeEnumSchema.describe("How many nodes may mount one claim at once. The values are Kubernetes' own `accessModes` strings, because this is recorded as the fact a PersistentVolumeClaim is rendered from rather than as a platform vocabulary that has to be translated at the one place it is used.
|
|
60217
|
+
sourceAccessMode: hostingVolumeAccessModeEnumSchema.describe("How many nodes may mount one claim at once. The values are Kubernetes' own `accessModes` strings, because this is recorded as the fact a PersistentVolumeClaim is rendered from rather than as a platform vocabulary that has to be translated at the one place it is used. `READ_WRITE_MANY` is a shared filesystem: consumers on different nodes may mount the claim. `READ_WRITE_ONCE` is a single-node attachment: the volume attaches to ONE node, every consumer has to be on that node, and the measured payoff is that many-small-file work stops crossing the network. A claim's access mode is immutable in Kubernetes. Once a volume is recorded as `READ_WRITE_ONCE` the environment can never serve its files from more than one node, which is why the layout that may use it is decided when the claim is created and why a later layout change is refused rather than applied (see `HostingEnvironmentService::optOutOfSharedEnvironmentPod()`).\n"),
|
|
60068
60218
|
sourceCsiDriver: string().nullable(),
|
|
60069
60219
|
sourceVolumeHandle: string().nullable(),
|
|
60070
60220
|
sourceCsiClusterId: string().nullable(),
|
|
@@ -60090,22 +60240,22 @@ var hostingDatabaseExportFormatEnumSchema = _enum([
|
|
|
60090
60240
|
"sql-gzip",
|
|
60091
60241
|
"pg-custom",
|
|
60092
60242
|
"tar-gzip"
|
|
60093
|
-
]).describe("The portable file format one engine's export is delivered in. It is an enum rather than a free string because the suffix, the recorded value and the restore instruction have to agree: the customer is told which tool opens the file, and a mismatch between what was dumped and what the page says reads as a corrupt download. `sql-gzip` is a plain SQL dump of the engine's own dialect, compressed, and is imported with that engine's client; `pg-custom` is PostgreSQL's own archive format and is restored with `pg_restore` rather than with `psql`.\n| |\n|---|\n| `sql-gzip` <br/> An uncompressed-SQL dump, gzipped. MySQL and MariaDB both deliver this. |\n| `pg-custom` <br/> `pg_dump --format=custom`, restorable only with `pg_restore`. |\n| `tar-gzip` <br/>
|
|
60243
|
+
]).describe("The portable file format one engine's export is delivered in. It is an enum rather than a free string because the suffix, the recorded value and the restore instruction have to agree: the customer is told which tool opens the file, and a mismatch between what was dumped and what the page says reads as a corrupt download. `sql-gzip` is a plain SQL dump of the engine's own dialect, compressed, and is imported with that engine's client; `pg-custom` is PostgreSQL's own archive format and is restored with `pg_restore` rather than with `psql`.\n| |\n|---|\n| `sql-gzip` <br/> An uncompressed-SQL dump, gzipped. MySQL and MariaDB both deliver this. |\n| `pg-custom` <br/> `pg_dump --format=custom`, restorable only with `pg_restore`. |\n| `tar-gzip` <br/> |");
|
|
60094
60244
|
var hostingDatabaseExportStatusEnumSchema = _enum([
|
|
60095
60245
|
"queued",
|
|
60096
60246
|
"running",
|
|
60097
60247
|
"succeeded",
|
|
60098
60248
|
"failed",
|
|
60099
60249
|
"expired"
|
|
60100
|
-
]).describe("How far one customer-requested database export has got. The states are the customer-visible contract, and `succeeded` is deliberately not \"the Job was
|
|
60250
|
+
]).describe("How far one customer-requested database export has got. The states are the customer-visible contract, and `succeeded` is deliberately not \"the Job was * applied\": it means the object was OBSERVED present with a measured size, which is what makes it offerable. `queued` and `running` are the only open states — they are what the one-open-export-per- environment constraint is written over — and a `failed` export is closed: its row is what tells the sweep that any object under its key is a partial dump nobody may download. `expired` is not the same as a deleted row. The row stays as the record of who asked and what was handed over; only the object is gone.\n| |\n|---|\n| `queued` <br/> Recorded and dispatched; no Job has been observed yet. |\n| `running` <br/> The export Job exists; its dump and upload have not been observed finishing. |\n| `succeeded` <br/> The object was observed present and is downloadable until `expires_at`. |\n| `failed` <br/> The Job refused or failed. Any object under its key is a partial dump and must be swept. |\n| `expired` <br/> The TTL passed and the object was removed. The row remains as the record. |");
|
|
60101
60251
|
var hostingDatabaseExportDataSchema = object({
|
|
60102
60252
|
uuid: string(),
|
|
60103
60253
|
databaseUuid: string().nullable(),
|
|
60104
60254
|
databaseName: string().nullable(),
|
|
60105
60255
|
application: string().nullable(),
|
|
60106
60256
|
engine: union([hostingWorkloadEnumSchema, _null()]),
|
|
60107
|
-
format: hostingDatabaseExportFormatEnumSchema.describe("The portable file format one engine's export is delivered in. It is an enum rather than a free string because the suffix, the recorded value and the restore instruction have to agree: the customer is told which tool opens the file, and a mismatch between what was dumped and what the page says reads as a corrupt download. `sql-gzip` is a plain SQL dump of the engine's own dialect, compressed, and is imported with that engine's client; `pg-custom` is PostgreSQL's own archive format and is restored with `pg_restore` rather than with `psql`.\n| |\n|---|\n| `sql-gzip` <br/> An uncompressed-SQL dump, gzipped. MySQL and MariaDB both deliver this. |\n| `pg-custom` <br/> `pg_dump --format=custom`, restorable only with `pg_restore`. |\n| `tar-gzip` <br/>
|
|
60108
|
-
status: hostingDatabaseExportStatusEnumSchema.describe("How far one customer-requested database export has got. The states are the customer-visible contract, and `succeeded` is deliberately not \"the Job was
|
|
60257
|
+
format: hostingDatabaseExportFormatEnumSchema.describe("The portable file format one engine's export is delivered in. It is an enum rather than a free string because the suffix, the recorded value and the restore instruction have to agree: the customer is told which tool opens the file, and a mismatch between what was dumped and what the page says reads as a corrupt download. `sql-gzip` is a plain SQL dump of the engine's own dialect, compressed, and is imported with that engine's client; `pg-custom` is PostgreSQL's own archive format and is restored with `pg_restore` rather than with `psql`.\n| |\n|---|\n| `sql-gzip` <br/> An uncompressed-SQL dump, gzipped. MySQL and MariaDB both deliver this. |\n| `pg-custom` <br/> `pg_dump --format=custom`, restorable only with `pg_restore`. |\n| `tar-gzip` <br/> |"),
|
|
60258
|
+
status: hostingDatabaseExportStatusEnumSchema.describe("How far one customer-requested database export has got. The states are the customer-visible contract, and `succeeded` is deliberately not \"the Job was * applied\": it means the object was OBSERVED present with a measured size, which is what makes it offerable. `queued` and `running` are the only open states — they are what the one-open-export-per- environment constraint is written over — and a `failed` export is closed: its row is what tells the sweep that any object under its key is a partial dump nobody may download. `expired` is not the same as a deleted row. The row stays as the record of who asked and what was handed over; only the object is gone.\n| |\n|---|\n| `queued` <br/> Recorded and dispatched; no Job has been observed yet. |\n| `running` <br/> The export Job exists; its dump and upload have not been observed finishing. |\n| `succeeded` <br/> The object was observed present and is downloadable until `expires_at`. |\n| `failed` <br/> The Job refused or failed. Any object under its key is a partial dump and must be swept. |\n| `expired` <br/> The TTL passed and the object was removed. The row remains as the record. |"),
|
|
60109
60259
|
sizeBytes: int().nullable(),
|
|
60110
60260
|
failureReason: string().nullable(),
|
|
60111
60261
|
requestedAt: datetime(),
|
|
@@ -60122,7 +60272,7 @@ var hostingDatabaseExportDataSchema = object({
|
|
|
60122
60272
|
object({
|
|
60123
60273
|
url: string(),
|
|
60124
60274
|
fileName: string(),
|
|
60125
|
-
format: hostingDatabaseExportFormatEnumSchema.describe("The portable file format one engine's export is delivered in. It is an enum rather than a free string because the suffix, the recorded value and the restore instruction have to agree: the customer is told which tool opens the file, and a mismatch between what was dumped and what the page says reads as a corrupt download. `sql-gzip` is a plain SQL dump of the engine's own dialect, compressed, and is imported with that engine's client; `pg-custom` is PostgreSQL's own archive format and is restored with `pg_restore` rather than with `psql`.\n| |\n|---|\n| `sql-gzip` <br/> An uncompressed-SQL dump, gzipped. MySQL and MariaDB both deliver this. |\n| `pg-custom` <br/> `pg_dump --format=custom`, restorable only with `pg_restore`. |\n| `tar-gzip` <br/>
|
|
60275
|
+
format: hostingDatabaseExportFormatEnumSchema.describe("The portable file format one engine's export is delivered in. It is an enum rather than a free string because the suffix, the recorded value and the restore instruction have to agree: the customer is told which tool opens the file, and a mismatch between what was dumped and what the page says reads as a corrupt download. `sql-gzip` is a plain SQL dump of the engine's own dialect, compressed, and is imported with that engine's client; `pg-custom` is PostgreSQL's own archive format and is restored with `pg_restore` rather than with `psql`.\n| |\n|---|\n| `sql-gzip` <br/> An uncompressed-SQL dump, gzipped. MySQL and MariaDB both deliver this. |\n| `pg-custom` <br/> `pg_dump --format=custom`, restorable only with `pg_restore`. |\n| `tar-gzip` <br/> |"),
|
|
60126
60276
|
restoreTool: string(),
|
|
60127
60277
|
expiresAt: datetime()
|
|
60128
60278
|
});
|
|
@@ -60219,13 +60369,13 @@ var hostingReleaseArtifactCompatibilityEnumSchema = _enum([
|
|
|
60219
60369
|
"paired",
|
|
60220
60370
|
"no_frontend_artifact",
|
|
60221
60371
|
"mismatched"
|
|
60222
|
-
]).describe("Whether a release's backend process digest and the artifact that serves its frontend belong together. An application that serves a browser build runs two immutably identified things: the pinned runtime image its backend processes execute, and the application bundle that carries the built frontend. They are not independent — the bundle was produced by a builder for one exact runtime, and running it on another is how a served page and a serving process end up disagreeing about the same release.
|
|
60372
|
+
]).describe("Whether a release's backend process digest and the artifact that serves its frontend belong together. An application that serves a browser build runs two immutably identified things: the pinned runtime image its backend processes execute, and the application bundle that carries the built frontend. They are not independent — the bundle was produced by a builder for one exact runtime, and running it on another is how a served page and a serving process end up disagreeing about the same release. `Paired` and `NoFrontendArtifact` are both deployable and mean different things, so they are different cases: a bundle release has a frontend artifact that has been checked against its process digest, while a legacy image-only release has none to check. Collapsing them into one \"ok\" would make the platform unable to say which of the two it is holding. `Mismatched` is a refusal with a reason, never a silent success: the release records one process digest and its bundle records another, so nothing here can state which release is being served.\n| |\n|---|\n| `paired` <br/> The bundle was built for exactly the process digest this release serves: the pair belongs together. |\n| `no_frontend_artifact` <br/> This release carries no bundle, so it has no compatibility-bound frontend artifact to pair. |\n| `mismatched` <br/> The bundle records a different runtime than the one this release serves: the pair does not belong together. |");
|
|
60223
60373
|
var hostingReleaseArtifactSetDataSchema = object({
|
|
60224
60374
|
releaseUuid: string(),
|
|
60225
60375
|
backendProcessDigest: string().nullable().describe("The immutable digest the backend processes run, or null when the release records none."),
|
|
60226
60376
|
frontendArtifactDigest: string().nullable().describe("The immutable application bundle that serves the frontend, or null for an image-only release."),
|
|
60227
60377
|
frontendBuiltForDigest: string().nullable().describe("The runtime image the frontend artifact was built for, as the bundle records it."),
|
|
60228
|
-
compatibility: hostingReleaseArtifactCompatibilityEnumSchema.describe("Whether a release's backend process digest and the artifact that serves its frontend belong together. An application that serves a browser build runs two immutably identified things: the pinned runtime image its backend processes execute, and the application bundle that carries the built frontend. They are not independent — the bundle was produced by a builder for one exact runtime, and running it on another is how a served page and a serving process end up disagreeing about the same release.
|
|
60378
|
+
compatibility: hostingReleaseArtifactCompatibilityEnumSchema.describe("Whether a release's backend process digest and the artifact that serves its frontend belong together. An application that serves a browser build runs two immutably identified things: the pinned runtime image its backend processes execute, and the application bundle that carries the built frontend. They are not independent — the bundle was produced by a builder for one exact runtime, and running it on another is how a served page and a serving process end up disagreeing about the same release. `Paired` and `NoFrontendArtifact` are both deployable and mean different things, so they are different cases: a bundle release has a frontend artifact that has been checked against its process digest, while a legacy image-only release has none to check. Collapsing them into one \"ok\" would make the platform unable to say which of the two it is holding. `Mismatched` is a refusal with a reason, never a silent success: the release records one process digest and its bundle records another, so nothing here can state which release is being served.\n| |\n|---|\n| `paired` <br/> The bundle was built for exactly the process digest this release serves: the pair belongs together. |\n| `no_frontend_artifact` <br/> This release carries no bundle, so it has no compatibility-bound frontend artifact to pair. |\n| `mismatched` <br/> The bundle records a different runtime than the one this release serves: the pair does not belong together. |"),
|
|
60229
60379
|
explanation: string().describe("The pairing's own sentence, so the reason a reader sees is the reason the platform decided.")
|
|
60230
60380
|
});
|
|
60231
60381
|
var hostingRetainedBuildLogDataSchema = object({
|
|
@@ -60548,7 +60698,7 @@ var hostingServiceIncidentDataSchema = object({
|
|
|
60548
60698
|
"no_database_declared",
|
|
60549
60699
|
"extension_missing",
|
|
60550
60700
|
"unanswered"
|
|
60551
|
-
]).describe("The closed set of safe reason codes an application observation can carry. These are the codes the application's own stats reading reports, and the only vocabulary an observer or a client message may name. They deliberately describe what was seen rather than why: `credential_refused` means a server evaluated the credential and refused it, while `server_unreachable` means no server answered — two different repairs, and only the first is about a password. A driver message, a host, a database name or a password never becomes one of these.
|
|
60701
|
+
]).describe("The closed set of safe reason codes an application observation can carry. These are the codes the application's own stats reading reports, and the only vocabulary an observer or a client message may name. They deliberately describe what was seen rather than why: `credential_refused` means a server evaluated the credential and refused it, while `server_unreachable` means no server answered — two different repairs, and only the first is about a password. A driver message, a host, a database name or a password never becomes one of these. {@see self::outcome()} owns the one decision each code makes, so the confirmation rule cannot drift between the observer that records a fact and the presentation that explains it.\n| |\n|---|\n| `credential_refused` <br/> MySQL error 1044/1045: a server answered and rejected the credential or the grant. |\n| `server_unreachable` <br/> A client-library code (2000+): the connection never reached a database server. |\n| `query_failed` <br/> The connection and the credential were accepted but the probe query did not answer. |\n| `server_error` <br/> A server answered and could not evaluate the question, for example at its connection ceiling. |\n| `probe_failed` <br/> The probe inside the application could not run at all, so acceptance is unknown. |\n| `no_database_declared` <br/> The application tree declares no database, so there is nothing for it to connect to. |\n| `extension_missing` <br/> The runtime has no MySQL client, so the probe could not be made. |\n| `unanswered` <br/> The application did not answer the reading at all. |"), _null()]),
|
|
60552
60702
|
summary: string().describe("The impact in plain language, safe to show a client."),
|
|
60553
60703
|
openedAt: string().describe("ISO-8601 UTC instant the outage was confirmed."),
|
|
60554
60704
|
lastObservedAt: string().describe("ISO-8601 UTC instant the platform last looked at the resource.")
|
|
@@ -60570,7 +60720,7 @@ var hostingProfileCoverageDataSchema = object({
|
|
|
60570
60720
|
"complete",
|
|
60571
60721
|
"short_of_catalog",
|
|
60572
60722
|
"not_participating"
|
|
60573
|
-
]).describe("Whether an environment's adopted shared profile covers every component the catalog expects. Named for what the state means rather than for the comparison that produces it. `NOT_PARTICIPATING` is deliberately not a kind of \"incomplete\": adoption is a customer action, and an environment that never adopted the shared set has nothing to be short of — the same distinction the forward repair migration and the operator listing both make.
|
|
60723
|
+
]).describe("Whether an environment's adopted shared profile covers every component the catalog expects. Named for what the state means rather than for the comparison that produces it. `NOT_PARTICIPATING` is deliberately not a kind of \"incomplete\": adoption is a customer action, and an environment that never adopted the shared set has nothing to be short of — the same distinction the forward repair migration and the operator listing both make. The mode exists because a bare list of missing keys cannot carry it: `COMPLETE` and `NOT_PARTICIPATING` both have no missing keys and mean opposite things, and a caller that cannot tell them apart would read an unadopted environment as a healthy one.\n").describe("Whether an environment's adopted shared profile covers every component the catalog expects. Named for what the state means rather than for the comparison that produces it. `NOT_PARTICIPATING` is deliberately not a kind of \"incomplete\": adoption is a customer action, and an environment that never adopted the shared set has nothing to be short of — the same distinction the forward repair migration and the operator listing both make. The mode exists because a bare list of missing keys cannot carry it: `COMPLETE` and `NOT_PARTICIPATING` both have no missing keys and mean opposite things, and a caller that cannot tell them apart would read an unadopted environment as a healthy one.\n"),
|
|
60574
60724
|
present: int(),
|
|
60575
60725
|
expected: int(),
|
|
60576
60726
|
missing: array(hostingMissingComponentDataSchema)
|
|
@@ -60711,13 +60861,13 @@ var hostingExportSourceDataSchema = object({
|
|
|
60711
60861
|
databaseUuid: string().nullable(),
|
|
60712
60862
|
capturedAt: datetime(),
|
|
60713
60863
|
expiresAt: datetime(),
|
|
60714
|
-
format: hostingDatabaseExportFormatEnumSchema.describe("The portable file format one engine's export is delivered in. It is an enum rather than a free string because the suffix, the recorded value and the restore instruction have to agree: the customer is told which tool opens the file, and a mismatch between what was dumped and what the page says reads as a corrupt download. `sql-gzip` is a plain SQL dump of the engine's own dialect, compressed, and is imported with that engine's client; `pg-custom` is PostgreSQL's own archive format and is restored with `pg_restore` rather than with `psql`.\n| |\n|---|\n| `sql-gzip` <br/> An uncompressed-SQL dump, gzipped. MySQL and MariaDB both deliver this. |\n| `pg-custom` <br/> `pg_dump --format=custom`, restorable only with `pg_restore`. |\n| `tar-gzip` <br/>
|
|
60864
|
+
format: hostingDatabaseExportFormatEnumSchema.describe("The portable file format one engine's export is delivered in. It is an enum rather than a free string because the suffix, the recorded value and the restore instruction have to agree: the customer is told which tool opens the file, and a mismatch between what was dumped and what the page says reads as a corrupt download. `sql-gzip` is a plain SQL dump of the engine's own dialect, compressed, and is imported with that engine's client; `pg-custom` is PostgreSQL's own archive format and is restored with `pg_restore` rather than with `psql`.\n| |\n|---|\n| `sql-gzip` <br/> An uncompressed-SQL dump, gzipped. MySQL and MariaDB both deliver this. |\n| `pg-custom` <br/> `pg_dump --format=custom`, restorable only with `pg_restore`. |\n| `tar-gzip` <br/> |"),
|
|
60715
60865
|
restoreTool: string(),
|
|
60716
60866
|
scopeLabel: string()
|
|
60717
60867
|
});
|
|
60718
60868
|
object({
|
|
60719
60869
|
environmentUuid: string(),
|
|
60720
|
-
status: hostingDatabaseExportStatusEnumSchema.describe("How far one customer-requested database export has got. The states are the customer-visible contract, and `succeeded` is deliberately not \"the Job was
|
|
60870
|
+
status: hostingDatabaseExportStatusEnumSchema.describe("How far one customer-requested database export has got. The states are the customer-visible contract, and `succeeded` is deliberately not \"the Job was * applied\": it means the object was OBSERVED present with a measured size, which is what makes it offerable. `queued` and `running` are the only open states — they are what the one-open-export-per- environment constraint is written over — and a `failed` export is closed: its row is what tells the sweep that any object under its key is a partial dump nobody may download. `expired` is not the same as a deleted row. The row stays as the record of who asked and what was handed over; only the object is gone.\n| |\n|---|\n| `queued` <br/> Recorded and dispatched; no Job has been observed yet. |\n| `running` <br/> The export Job exists; its dump and upload have not been observed finishing. |\n| `succeeded` <br/> The object was observed present and is downloadable until `expires_at`. |\n| `failed` <br/> The Job refused or failed. Any object under its key is a partial dump and must be swept. |\n| `expired` <br/> The TTL passed and the object was removed. The row remains as the record. |"),
|
|
60721
60871
|
sources: array(hostingExportSourceDataSchema),
|
|
60722
60872
|
failureReason: string().nullable()
|
|
60723
60873
|
});
|
|
@@ -61022,10 +61172,10 @@ var hostingMailRelayDiagnosisStepStatusEnumSchema = _enum([
|
|
|
61022
61172
|
"passed",
|
|
61023
61173
|
"failed",
|
|
61024
61174
|
"not_reached"
|
|
61025
|
-
]).describe("What happened at one diagnosis step.\n| |\n|---|\n| `passed` <br/>
|
|
61175
|
+
]).describe("What happened at one diagnosis step.\n| |\n|---|\n| `passed` <br/> |\n| `failed` <br/> |\n| `not_reached` <br/> An earlier step failed, so this one was never tried. |");
|
|
61026
61176
|
var hostingMailRelayDiagnosisStepDataSchema = object({
|
|
61027
61177
|
step: hostingMailRelayDiagnosisStepEnumSchema.describe("One step of a mail relay diagnosis, in the order a real send takes them. The order is the canonical display order; on a STARTTLS port the server's greeting is read before TLS, and the result lists the steps in the order the run actually took them.\n| |\n|---|\n| `configuration` <br/> The five relay values are rendered for the site and the test recipient is an address. |\n| `dns` <br/> The relay host resolves from the environment's network. |\n| `connect` <br/> The relay port accepts a TCP connection from the environment's network. |\n| `tls` <br/> TLS is negotiated, implicitly on 465 or with STARTTLS, with a certificate valid for the host. |\n| `greeting` <br/> The server greets and answers EHLO with the sign-in methods it offers. |\n| `auth` <br/> The relay's username and password are accepted. |\n| `sender` <br/> The relay accepts the configured From address as the sender. |\n| `recipient` <br/> The relay accepts the test recipient. |\n| `message` <br/> The relay accepts the test message for delivery. |"),
|
|
61028
|
-
status: hostingMailRelayDiagnosisStepStatusEnumSchema.describe("What happened at one diagnosis step.\n| |\n|---|\n| `passed` <br/>
|
|
61178
|
+
status: hostingMailRelayDiagnosisStepStatusEnumSchema.describe("What happened at one diagnosis step.\n| |\n|---|\n| `passed` <br/> |\n| `failed` <br/> |\n| `not_reached` <br/> An earlier step failed, so this one was never tried. |"),
|
|
61029
61179
|
detail: string().describe("What was found, in words, with the server's own answer when it refused. Never a credential.")
|
|
61030
61180
|
});
|
|
61031
61181
|
var hostingMailRelayDiagnosisLineDataSchema = object({
|
|
@@ -61113,7 +61263,7 @@ var hostingOperationKindEnumSchema = _enum([
|
|
|
61113
61263
|
"update",
|
|
61114
61264
|
"restore",
|
|
61115
61265
|
"backup"
|
|
61116
|
-
]).describe("The lifecycle operations whose timing Hosting records. Each case is a family whose own owner already records when it started, what it was in and how it ended; `HostingOperationSourceImport` only projects those recorded instants into the shared timing tables. No case exists for a family without stage evidence of its own, and nothing here is a workflow engine: a case names work another owner already performed.
|
|
61266
|
+
]).describe("The lifecycle operations whose timing Hosting records. Each case is a family whose own owner already records when it started, what it was in and how it ended; `HostingOperationSourceImport` only projects those recorded instants into the shared timing tables. No case exists for a family without stage evidence of its own, and nothing here is a workflow engine: a case names work another owner already performed. - `reconcile` — the reconcile journal's named stages (`HostingDiagnosticsJournal`), which is what provisioning, updates and rollouts all converge through. - `build` — one `HostingBuild` attempt: queued, then run to an artifact. - `update` — one `HostingRelease` activation: prepared, then applied and made active. - `restore` — one `HostingApplicationRecovery` review/reset/restore, with its recorded phases. - `backup` — one observed backup run per track, as the existing backup readers saw it. The readers are cluster reads, so the projection is written where the platform already observes out of band; the operator's read never calls the cluster.\n");
|
|
61117
61267
|
var hostingOperationPhaseStatisticDataSchema = object({
|
|
61118
61268
|
stepKey: string(),
|
|
61119
61269
|
samples: int(),
|
|
@@ -61756,7 +61906,7 @@ var hostingServiceDataSchema = object({
|
|
|
61756
61906
|
consumers: array(string()),
|
|
61757
61907
|
dependencies: array(string())
|
|
61758
61908
|
});
|
|
61759
|
-
var hostingServiceDataDispositionEnumSchema = _enum(["copy-taken", "accepted-loss"]).describe("What a client decided about a service's data at the moment they deleted it. It is a choice rather than a flag because both answers are legitimate and they mean different things: a copy was taken and handed over, or the customer knowingly let the data go. Recording which one happened is what lets the platform answer \"was this customer's data destroyed because they chose to,
|
|
61909
|
+
var hostingServiceDataDispositionEnumSchema = _enum(["copy-taken", "accepted-loss"]).describe("What a client decided about a service's data at the moment they deleted it. It is a choice rather than a flag because both answers are legitimate and they mean different things: a copy was taken and handed over, or the customer knowingly let the data go. Recording which one happened is what lets the platform answer \"was this customer's data destroyed because they chose to, * or because nobody offered them a copy\" — a question a boolean cannot answer. `copy-taken` names the customer's own copy of the latest backup. Until the export path exists that copy is arranged with staff, so this records what the customer confirmed rather than what the platform performed, and [`docs/plans/near-future/62_customer_downloadable_backup_exports.md`] owns making it self-service.\n");
|
|
61760
61910
|
var hostingServiceDeletionProtectionDataSchema = object({
|
|
61761
61911
|
environmentUuid: string(),
|
|
61762
61912
|
workloadUuid: string(),
|
|
@@ -62010,7 +62160,7 @@ var siteUptimeStatusSchema = _enum([
|
|
|
62010
62160
|
"failing",
|
|
62011
62161
|
"down",
|
|
62012
62162
|
"paused"
|
|
62013
|
-
]).describe("SiteUptimeStatus is the uptime state a domain shows.\n| |\n|---|\n| `unknown` <br/> No check in the last fifteen minutes, or none yet. |\n| `up` <br/>
|
|
62163
|
+
]).describe("SiteUptimeStatus is the uptime state a domain shows.\n| |\n|---|\n| `unknown` <br/> No check in the last fifteen minutes, or none yet. |\n| `up` <br/> |\n| `failing` <br/> One failed check, not yet an outage. |\n| `down` <br/> An open incident: two or more failed checks in a row. |\n| `paused` <br/> |");
|
|
62014
62164
|
var siteUptimeWindowSchema = object({
|
|
62015
62165
|
checks: int(),
|
|
62016
62166
|
upChecks: int(),
|
|
@@ -62028,7 +62178,7 @@ var siteUptimeDaySchema = object({
|
|
|
62028
62178
|
upPercent: number().nullable()
|
|
62029
62179
|
});
|
|
62030
62180
|
var siteReportUptimeSchema = object({
|
|
62031
|
-
status: siteUptimeStatusSchema.describe("SiteUptimeStatus is the uptime state a domain shows.\n| |\n|---|\n| `unknown` <br/> No check in the last fifteen minutes, or none yet. |\n| `up` <br/>
|
|
62181
|
+
status: siteUptimeStatusSchema.describe("SiteUptimeStatus is the uptime state a domain shows.\n| |\n|---|\n| `unknown` <br/> No check in the last fifteen minutes, or none yet. |\n| `up` <br/> |\n| `failing` <br/> One failed check, not yet an outage. |\n| `down` <br/> An open incident: two or more failed checks in a row. |\n| `paused` <br/> |"),
|
|
62032
62182
|
windows: siteUptimeWindowsSchema,
|
|
62033
62183
|
days: array(siteUptimeDaySchema),
|
|
62034
62184
|
responseMs: int().nullable(),
|
|
@@ -62131,11 +62281,11 @@ var siteSearchConnectionStatusSchema = _enum([
|
|
|
62131
62281
|
"active",
|
|
62132
62282
|
"failing",
|
|
62133
62283
|
"revoked"
|
|
62134
|
-
]).describe("SiteSearchConnectionStatus is the import state of one provider connection.\n| |\n|---|\n| `pending` <br/> Connected, not yet imported. |\n| `active` <br/>
|
|
62284
|
+
]).describe("SiteSearchConnectionStatus is the import state of one provider connection.\n| |\n|---|\n| `pending` <br/> Connected, not yet imported. |\n| `active` <br/> |\n| `failing` <br/> The latest import failed; lastFailure says why. |\n| `revoked` <br/> The provider no longer lets Custd read the property. |");
|
|
62135
62285
|
var hostingSiteSearchConnectionDataSchema = object({
|
|
62136
62286
|
provider: siteSearchProviderSchema.describe("SiteSearchProvider is a search engine Custd imports a domain's search numbers from.\n| |\n|---|\n| `google` <br/> Google Search Console, read through Custd's service account added as a user on the property. |\n| `bing` <br/> Bing Webmaster Tools, read with the client's own API key. |"),
|
|
62137
62287
|
property: string(),
|
|
62138
|
-
status: siteSearchConnectionStatusSchema.describe("SiteSearchConnectionStatus is the import state of one provider connection.\n| |\n|---|\n| `pending` <br/> Connected, not yet imported. |\n| `active` <br/>
|
|
62288
|
+
status: siteSearchConnectionStatusSchema.describe("SiteSearchConnectionStatus is the import state of one provider connection.\n| |\n|---|\n| `pending` <br/> Connected, not yet imported. |\n| `active` <br/> |\n| `failing` <br/> The latest import failed; lastFailure says why. |\n| `revoked` <br/> The provider no longer lets Custd read the property. |"),
|
|
62139
62289
|
importedThrough: string().nullable(),
|
|
62140
62290
|
lastImportedAt: string().nullable()
|
|
62141
62291
|
});
|
|
@@ -62579,7 +62729,7 @@ var hostingTagDecisionEnumSchema = _enum([
|
|
|
62579
62729
|
"major_bump",
|
|
62580
62730
|
"prerelease",
|
|
62581
62731
|
"not_comparable"
|
|
62582
|
-
]).describe("What a delivered tag means for the tag a binding recorded. \"Not adopted\" is a first-class outcome here rather than a failure. A major bump under a line binding, a tag that moved, a pre-release under a stable rule — each is the platform OBSERVING a push and refusing it by name, and each gets its own case so the run can record which rule refused it. Only {@see self::Adopted} moves a deployment; everything else leaves the recorded tag in force.
|
|
62732
|
+
]).describe("What a delivered tag means for the tag a binding recorded. \"Not adopted\" is a first-class outcome here rather than a failure. A major bump under a line binding, a tag that moved, a pre-release under a stable rule — each is the platform OBSERVING a push and refusing it by name, and each gets its own case so the run can record which rule refused it. Only {@see self::Adopted} moves a deployment; everything else leaves the recorded tag in force. The cases that are refusals map to the named refusals in the obligation: an unknown tag and a non-version under a tracking rule are refused when the tag is BOUND, because they are facts about the name; a moved, backwards, major or pre-release tag is refused when it is DELIVERED, because they are facts about a push relative to what is already recorded. A tag that is legal when bound can always be followed by one that is not.\n| |\n|---|\n| `adopted` <br/> The delivered tag advances the binding, so it is adopted. |\n| `already_recorded` <br/> The delivered tag is the one already recorded; nothing changes. |\n| `not_tracked` <br/> An exact binding adopts the tag it names and no other. |\n| `moved` <br/> The recorded tag now resolves to a different commit than the one recorded for it. |\n| `backwards` <br/> The delivered tag is older than the recorded one. |\n| `major_bump` <br/> The delivered tag crosses a major version, which is a decision rather than a push. |\n| `prerelease` <br/> A pre-release cannot advance a binding made on a stable release. |\n| `not_comparable` <br/> A line binding cannot order a delivered tag that is not a version. |");
|
|
62583
62733
|
var hostingTuningPreviewWorkloadDataSchema = object({
|
|
62584
62734
|
name: string(),
|
|
62585
62735
|
type: string(),
|
|
@@ -62610,10 +62760,10 @@ var hostingUpdateCandidateReasonEnumSchema = _enum([
|
|
|
62610
62760
|
"tags_are_not_versions",
|
|
62611
62761
|
"version_list_truncated",
|
|
62612
62762
|
"version_rule_refused"
|
|
62613
|
-
]).describe("Why an upstream revision is, or is not, a candidate for one environment. \"Not a candidate\" is a first-class outcome rather than an absence, for the same reason {@see HostingTagDecisionEnum} refuses a delivered tag by name: a customer reading a preview has to be told which rule applied instead of being shown a bare false. Every case therefore carries its own sentence, and only {@see self::Candidate} says a revision could move.
|
|
62763
|
+
]).describe("Why an upstream revision is, or is not, a candidate for one environment. \"Not a candidate\" is a first-class outcome rather than an absence, for the same reason {@see HostingTagDecisionEnum} refuses a delivered tag by name: a customer reading a preview has to be told which rule applied instead of being shown a bare false. Every case therefore carries its own sentence, and only {@see self::Candidate} says a revision could move. A `VersionRuleRefused` refusal is decided entirely by the existing tag rule, so its sentence comes from {@see HostingTagDecisionEnum::reason()} rather than being restated here — one vocabulary for the version rule's outcomes, not two. Nothing is persisted from this enum. It is a decision read at the moment it is asked for, which is why it is a hand-written enum beside the generated catalog enums rather than a type table.\n| |\n|---|\n| `candidate` <br/> Upstream offers a revision this binding's rule adopts, and the environment is not serving it. |\n| `not_bound` <br/> No repository is bound, so there is no upstream to take a revision from. |\n| `not_opted_in` <br/> The customer has not opted in to updates from this binding. |\n| `paused` <br/> The customer paused updates for this binding, so it declines to be a candidate. |\n| `no_observation` <br/> No pass has observed this binding yet, so no revision is known to be offered. |\n| `observation_names_no_revision` <br/> An observation is recorded but names no upstream revision. |\n| `observation_follows_another_ref` <br/> The observation was taken of a ref this binding no longer follows. |\n| `nothing_serving` <br/> Nothing is deployed for this application, so there is no update to consider. |\n| `already_serving` <br/> The revision upstream offers is the revision this application already serves. |\n| `no_offered_version` <br/> The binding follows a tag, and nothing has offered a version from the repository yet. |\n| `versions_unreadable` <br/> The repository's versions could not be read now: no connection, a revoked grant or a provider fault. |\n| `no_versions_published` <br/> The repository publishes no tags at all, so there is no version to consider. |\n| `tags_are_not_versions` <br/> The repository has tags and none is a version, so ordering them would invent a rule. |\n| `version_list_truncated` <br/> The tag list stopped at its read ceiling, so which version is newest cannot be claimed. |\n| `version_rule_refused` <br/> The binding's tag rule does not adopt the version upstream offers. |");
|
|
62614
62764
|
var hostingUpdateCandidateDataSchema = object({
|
|
62615
62765
|
applicationUuid: string(),
|
|
62616
|
-
reason: hostingUpdateCandidateReasonEnumSchema.describe("Why an upstream revision is, or is not, a candidate for one environment. \"Not a candidate\" is a first-class outcome rather than an absence, for the same reason {@see HostingTagDecisionEnum} refuses a delivered tag by name: a customer reading a preview has to be told which rule applied instead of being shown a bare false. Every case therefore carries its own sentence, and only {@see self::Candidate} says a revision could move.
|
|
62766
|
+
reason: hostingUpdateCandidateReasonEnumSchema.describe("Why an upstream revision is, or is not, a candidate for one environment. \"Not a candidate\" is a first-class outcome rather than an absence, for the same reason {@see HostingTagDecisionEnum} refuses a delivered tag by name: a customer reading a preview has to be told which rule applied instead of being shown a bare false. Every case therefore carries its own sentence, and only {@see self::Candidate} says a revision could move. A `VersionRuleRefused` refusal is decided entirely by the existing tag rule, so its sentence comes from {@see HostingTagDecisionEnum::reason()} rather than being restated here — one vocabulary for the version rule's outcomes, not two. Nothing is persisted from this enum. It is a decision read at the moment it is asked for, which is why it is a hand-written enum beside the generated catalog enums rather than a type table.\n| |\n|---|\n| `candidate` <br/> Upstream offers a revision this binding's rule adopts, and the environment is not serving it. |\n| `not_bound` <br/> No repository is bound, so there is no upstream to take a revision from. |\n| `not_opted_in` <br/> The customer has not opted in to updates from this binding. |\n| `paused` <br/> The customer paused updates for this binding, so it declines to be a candidate. |\n| `no_observation` <br/> No pass has observed this binding yet, so no revision is known to be offered. |\n| `observation_names_no_revision` <br/> An observation is recorded but names no upstream revision. |\n| `observation_follows_another_ref` <br/> The observation was taken of a ref this binding no longer follows. |\n| `nothing_serving` <br/> Nothing is deployed for this application, so there is no update to consider. |\n| `already_serving` <br/> The revision upstream offers is the revision this application already serves. |\n| `no_offered_version` <br/> The binding follows a tag, and nothing has offered a version from the repository yet. |\n| `versions_unreadable` <br/> The repository's versions could not be read now: no connection, a revoked grant or a provider fault. |\n| `no_versions_published` <br/> The repository publishes no tags at all, so there is no version to consider. |\n| `tags_are_not_versions` <br/> The repository has tags and none is a version, so ordering them would invent a rule. |\n| `version_list_truncated` <br/> The tag list stopped at its read ceiling, so which version is newest cannot be claimed. |\n| `version_rule_refused` <br/> The binding's tag rule does not adopt the version upstream offers. |"),
|
|
62617
62767
|
trackedRef: string().nullable().describe("The branch or tag this binding follows, as the decision read it."),
|
|
62618
62768
|
offeredRevision: string().nullable().describe("What upstream offers, or null when the decision refused before naming one."),
|
|
62619
62769
|
servingRevision: string().nullable().describe("What the environment serves now, in the same terms."),
|
|
@@ -62976,7 +63126,7 @@ object({
|
|
|
62976
63126
|
durationMonths: int().nullable().describe("Null is a continual price: it runs until an operator ends the window."),
|
|
62977
63127
|
packageKey: string().nullable().describe("The one package the code prices, or null for whichever package the client buys first."),
|
|
62978
63128
|
expiresAt: string().nullable(),
|
|
62979
|
-
kind: billingDiscountKindEnumSchema.describe("What a discount code states: a price, or a share off the list price. A code's promise is an **amount**, because an amount is what a client is charged and what a price window records. A percentage is therefore a way of *deriving* that amount once, at the month the window opens, against the list price effective then — not a second pricing rule that would reprice a settled month when a list price moves.
|
|
63129
|
+
kind: billingDiscountKindEnumSchema.describe("What a discount code states: a price, or a share off the list price. A code's promise is an **amount**, because an amount is what a client is charged and what a price window records. A percentage is therefore a way of *deriving* that amount once, at the month the window opens, against the list price effective then — not a second pricing rule that would reprice a settled month when a list price moves. The kind is stored rather than inferred from which column is filled, so a half-written code cannot mean two things and an existing row keeps its original meaning as `amount`.\n"),
|
|
62980
63130
|
basisPoints: int().nullable().describe("The share off the list price in ten-thousandths; null for a code that states a price instead."),
|
|
62981
63131
|
listAmountCents: int().nullable().describe("The package's own monthly price net of VAT when one was named and the book states it, otherwise null."),
|
|
62982
63132
|
applies: boolean().describe("Whether applying this code to the named package would be recorded. False when the code prices another\npackage, or when its amount is not below that package's own price - the two refusals a redemption makes.")
|
|
@@ -63885,7 +64035,7 @@ var stateManagerIntentRequestSchema = object({
|
|
|
63885
64035
|
}).describe("The manager's intent-resolution request.\n\nThe run reference is the exact manager tuple the callback must bind and echo.\nThe intent reference is the Laravel-owned record it must resolve. Neither a\ncompany, an actor nor a credential is accepted: the handler resolves those\nserver-side and a caller-supplied identity grants no authority.\n\nThe callback is a Laravel/HTTP boundary, so its own fields are camelCase like\nthe rest of the API. The complete unfiltered payload is checked against the one\nshared callback schema, so a superseded snake_case, mixed or unknown-field body\nis refused rather than silently coerced by Laravel's field filtering.");
|
|
63886
64036
|
var storeBillingDiscountCodeRequestSchema = object({
|
|
63887
64037
|
company: string().max(64).nullish(),
|
|
63888
|
-
kind: billingDiscountKindEnumSchema.optional().describe("What a discount code states: a price, or a share off the list price. A code's promise is an **amount**, because an amount is what a client is charged and what a price window records. A percentage is therefore a way of *deriving* that amount once, at the month the window opens, against the list price effective then — not a second pricing rule that would reprice a settled month when a list price moves.
|
|
64038
|
+
kind: billingDiscountKindEnumSchema.optional().describe("What a discount code states: a price, or a share off the list price. A code's promise is an **amount**, because an amount is what a client is charged and what a price window records. A percentage is therefore a way of *deriving* that amount once, at the month the window opens, against the list price effective then — not a second pricing rule that would reprice a settled month when a list price moves. The kind is stored rather than inferred from which column is filled, so a half-written code cannot mean two things and an existing row keeps its original meaning as `amount`.\n"),
|
|
63889
64039
|
product: billingProductEnumSchema.optional().describe("The tariff lines our documents define. `MHU` is the recurring managed hosting unit; `MHS` is the one-off managed hosting setup. `STO` is one recurring 10 GB storage block and `TRF` is one recurring chargeable 10 GB transfer block; the product variant (object storage, disk) is the rate's `package_key`, which is the price book's existing scope. `SUN` is a staff-issued sundry or time line, also selectable in the existing one-off price book. Product codes describe what a document bills as, while package keys scope the agreed price.\n"),
|
|
63890
64040
|
packageKey: string().max(64).nullish(),
|
|
63891
64041
|
amountCents: int().min(0).max(1e8).optional(),
|
|
@@ -64267,7 +64417,7 @@ var storePlatformHostingEnvironmentRequestSchema = object({
|
|
|
64267
64417
|
name: string().max(100),
|
|
64268
64418
|
webServer: string().max(32).nullish(),
|
|
64269
64419
|
runtimeVersion: string().max(16).nullish(),
|
|
64270
|
-
serverMode: hostingWorkloadServerModeEnumSchema.optional().describe("Whether a workload's database server is shared with the rest of its engine, or bought for it alone. An environment runs ONE server per engine, and every database of that engine binds to it. That is the purchase's shape: one server's memory and CPU serve every application on the engine. A second same-engine server splits that purchase between two Pods that each must still clear the engine's own floor — measured on Home 2026-10-19, where such a split left an engine 512Mi and it was OOM-killed on every boot.
|
|
64420
|
+
serverMode: hostingWorkloadServerModeEnumSchema.optional().describe("Whether a workload's database server is shared with the rest of its engine, or bought for it alone. An environment runs ONE server per engine, and every database of that engine binds to it. That is the purchase's shape: one server's memory and CPU serve every application on the engine. A second same-engine server splits that purchase between two Pods that each must still clear the engine's own floor — measured on Home 2026-10-19, where such a split left an engine 512Mi and it was OOM-killed on every boot. A second server is therefore a **client capability request** and never a side effect of declaring a workload. `DEDICATED` is that request: the workload pays its own floor out of the environment's budget, and the reconciler binds the databases to it by name rather than by engine. `SHARED` is every workload that did not ask. This is a named mode rather than a boolean because the same field may grow a third value (for example a replica-bearing server) without reinterpreting two call sites.\n| |\n|---|\n| `shared` <br/> The environment's existing server for this engine serves this workload's databases. |\n| `dedicated` <br/> The client asked for a server of this engine for this workload alone. |"),
|
|
64271
64421
|
replicas: int().min(1),
|
|
64272
64422
|
resources: object({
|
|
64273
64423
|
cpuRequestMillicores: int().min(1),
|
|
@@ -64356,7 +64506,7 @@ var updateBillingCustomerProfileRequestSchema = object({
|
|
|
64356
64506
|
postalCode: string().max(16).nullish(),
|
|
64357
64507
|
countryCode: string().min(2).max(2).optional(),
|
|
64358
64508
|
dueDays: int().nullish(),
|
|
64359
|
-
paymentTiming: billingPaymentTimingEnumSchema.optional().describe("When a client is invoiced for the month it is served. Most of our clients pay before the service: the invoice is raised at the start of the month it prices, which is what makes the money arrive before the cost is incurred. Others are agreed to pay after it, and that is a commercial term per client rather than a platform-wide setting — so it is recorded on the client's billing identity, where the rest of \"how this client is invoiced\" already lives.
|
|
64509
|
+
paymentTiming: billingPaymentTimingEnumSchema.optional().describe("When a client is invoiced for the month it is served. Most of our clients pay before the service: the invoice is raised at the start of the month it prices, which is what makes the money arrive before the cost is incurred. Others are agreed to pay after it, and that is a commercial term per client rather than a platform-wide setting — so it is recorded on the client's billing identity, where the rest of \"how this client is invoiced\" already lives. It decides one thing only: whether a month must have ENDED before its document may be issued. `post_pay` keeps that requirement, because its supplies are only complete then. `pre_pay` issues once the month has STARTED, because what it sells is the month itself and the price is known on its first day.\n| |\n|---|\n| `pre_pay` <br/> Invoiced at the start of the month it prices, before the service is delivered. |\n| `post_pay` <br/> Invoiced after the month it prices has ended. The default, because it never bills ahead of supply. |")
|
|
64360
64510
|
}).describe("A partial change to one company's billing particulars.\n\nEvery field is `sometimes`, which is the whole point: a client may save half a profile today and the\nother half next week, so an absent field is left alone and an explicit null clears one. That\ndistinction is the DTO's (`Optional` versus null); this request only establishes the shape.\n\nThe rules the values must satisfy against each other — a registered vendor needs a number, only a\nSouth African supply is invoiced in phase 1, the contact address must be a real address — belong to\n`BillingCustomerProfileService`, because a command or job reaches the same row without this request.\nThe lengths here mirror the migration's columns, so a value that cannot be stored is refused with a\nfield error rather than a database error.");
|
|
64361
64511
|
var updateBillingExportProfileRequestSchema = object({
|
|
64362
64512
|
name: string().max(64),
|
|
@@ -70965,7 +71115,7 @@ object({
|
|
|
70965
71115
|
environment: string(),
|
|
70966
71116
|
migration: string()
|
|
70967
71117
|
});
|
|
70968
|
-
hostingOperationKindEnumSchema.optional().describe("The lifecycle operations whose timing Hosting records. Each case is a family whose own owner already records when it started, what it was in and how it ended; `HostingOperationSourceImport` only projects those recorded instants into the shared timing tables. No case exists for a family without stage evidence of its own, and nothing here is a workflow engine: a case names work another owner already performed.
|
|
71118
|
+
hostingOperationKindEnumSchema.optional().describe("The lifecycle operations whose timing Hosting records. Each case is a family whose own owner already records when it started, what it was in and how it ended; `HostingOperationSourceImport` only projects those recorded instants into the shared timing tables. No case exists for a family without stage evidence of its own, and nothing here is a workflow engine: a case names work another owner already performed. - `reconcile` — the reconcile journal's named stages (`HostingDiagnosticsJournal`), which is what provisioning, updates and rollouts all converge through. - `build` — one `HostingBuild` attempt: queued, then run to an artifact. - `update` — one `HostingRelease` activation: prepared, then applied and made active. - `restore` — one `HostingApplicationRecovery` review/reset/restore, with its recorded phases. - `backup` — one observed backup run per track, as the existing backup readers saw it. The readers are cluster reads, so the projection is written where the platform already observes out of band; the operator's read never calls the cluster.\n");
|
|
70969
71119
|
union([
|
|
70970
71120
|
object({ message: string().describe("Error overview.") }),
|
|
70971
71121
|
messageDataSchema,
|
|
@@ -70974,7 +71124,7 @@ union([
|
|
|
70974
71124
|
errors: record$3(string(), array(string())).describe("A detailed description of each field that failed validation.")
|
|
70975
71125
|
})
|
|
70976
71126
|
]);
|
|
70977
|
-
object({ kind: hostingOperationKindEnumSchema.optional().describe("The lifecycle operations whose timing Hosting records. Each case is a family whose own owner already records when it started, what it was in and how it ended; `HostingOperationSourceImport` only projects those recorded instants into the shared timing tables. No case exists for a family without stage evidence of its own, and nothing here is a workflow engine: a case names work another owner already performed.
|
|
71127
|
+
object({ kind: hostingOperationKindEnumSchema.optional().describe("The lifecycle operations whose timing Hosting records. Each case is a family whose own owner already records when it started, what it was in and how it ended; `HostingOperationSourceImport` only projects those recorded instants into the shared timing tables. No case exists for a family without stage evidence of its own, and nothing here is a workflow engine: a case names work another owner already performed. - `reconcile` — the reconcile journal's named stages (`HostingDiagnosticsJournal`), which is what provisioning, updates and rollouts all converge through. - `build` — one `HostingBuild` attempt: queued, then run to an artifact. - `update` — one `HostingRelease` activation: prepared, then applied and made active. - `restore` — one `HostingApplicationRecovery` review/reset/restore, with its recorded phases. - `backup` — one observed backup run per track, as the existing backup readers saw it. The readers are cluster reads, so the projection is written where the platform already observes out of band; the operator's read never calls the cluster.\n") });
|
|
70978
71128
|
union([
|
|
70979
71129
|
object({ message: string().describe("Error overview.") }),
|
|
70980
71130
|
messageDataSchema,
|
|
@@ -78645,6 +78795,44 @@ function bucketLine(review) {
|
|
|
78645
78795
|
const binds = bucket.binds ? ", then binds it to this environment before any application" : " and finds it already bound to this environment";
|
|
78646
78796
|
return [` It ${founds} bucket ${bucket.name} with ${String(bucket.packageGib)} GiB from the package${binds}, and buys nothing.`];
|
|
78647
78797
|
}
|
|
78798
|
+
// src/commands/environment-status-text.ts
|
|
78799
|
+
/** How the platform opens the message of a change it is still applying after a failed attempt. */
|
|
78800
|
+
var RETRYING_PREFIX = "Retrying after:";
|
|
78801
|
+
/** Whether the platform is retrying the change on its own, which its message words like a failure. */
|
|
78802
|
+
function isRetrying(status) {
|
|
78803
|
+
return status.status === "applying" && status.message.trim().startsWith(RETRYING_PREFIX);
|
|
78804
|
+
}
|
|
78805
|
+
/**
|
|
78806
|
+
* What a status says beyond its word, in the vocabulary a failed build or release is told in.
|
|
78807
|
+
*
|
|
78808
|
+
* A failed change leads with the API's explanation — why, who acts next, what to do, whether a retry helps — and the
|
|
78809
|
+
* raw message follows as the platform's record. A change the platform is retrying says so first, because its message
|
|
78810
|
+
* is written like a failure while the status is still `applying`. Any other status has no story and prints nothing.
|
|
78811
|
+
*/
|
|
78812
|
+
function statusStoryLines(status) {
|
|
78813
|
+
const explanation = status.explanation ?? null;
|
|
78814
|
+
if (status.status === "failed" && explanation !== null) return failureLines$1({
|
|
78815
|
+
explanation,
|
|
78816
|
+
failureReason: status.message
|
|
78817
|
+
});
|
|
78818
|
+
return isRetrying(status) ? [" Still applying; the platform is retrying.", ` Platform's record: ${status.message.trim()}`] : [];
|
|
78819
|
+
}
|
|
78820
|
+
/**
|
|
78821
|
+
* The platform's own message for a waited reading, when it wrote one and the status lines have not already told it.
|
|
78822
|
+
*
|
|
78823
|
+
* The status word says whether the generation was applied; the message is the only thing that says why not, so it is
|
|
78824
|
+
* printed rather than held back to the JSON answer.
|
|
78825
|
+
*/
|
|
78826
|
+
function statusMessage(status) {
|
|
78827
|
+
const message = status.message.trim();
|
|
78828
|
+
return message === "" || statusStoryLines(status).length > 0 ? "" : `\n message ${message}`;
|
|
78829
|
+
}
|
|
78830
|
+
/** What a wait's progress line adds for one reading: the retry said plainly, the platform's message otherwise. */
|
|
78831
|
+
function statusProgressSuffix(status) {
|
|
78832
|
+
const message = status.message.trim();
|
|
78833
|
+
if (isRetrying(status)) return `: still applying; the platform is retrying (platform's record: ${message})`;
|
|
78834
|
+
return message === "" ? "" : `: ${message}`;
|
|
78835
|
+
}
|
|
78648
78836
|
// src/commands/environment-configuration-readiness.ts
|
|
78649
78837
|
var READY_WAIT_MS = 6e5;
|
|
78650
78838
|
var READY_POLL_MS = 3e3;
|
|
@@ -78665,7 +78853,7 @@ async function awaitReadiness(company, environmentUuid, generation, progress, de
|
|
|
78665
78853
|
const reported = status.message.trim();
|
|
78666
78854
|
if (status.status === "failed" && status.generation >= generation) throw new ApiError(422, reported === "" ? `The platform reports generation ${String(generation)} of environment ${environmentUuid} as failed, without a message.` : reported);
|
|
78667
78855
|
if (status.status === "ready" && status.appliedGeneration >= generation) return environment;
|
|
78668
|
-
progress?.report(`environment ${status.status}, waiting for generation ${String(generation)} (applied ${String(status.appliedGeneration)})${
|
|
78856
|
+
progress?.report(`environment ${status.status}, waiting for generation ${String(generation)} (applied ${String(status.appliedGeneration)})${statusProgressSuffix(status)}`);
|
|
78669
78857
|
await new Promise((resolve) => setTimeout(resolve, READY_POLL_MS));
|
|
78670
78858
|
}
|
|
78671
78859
|
}
|
|
@@ -82633,8 +82821,17 @@ function domainLine(one) {
|
|
|
82633
82821
|
lines.push(` ownership check: ${one.ownershipCheckDetail}`);
|
|
82634
82822
|
for (const record of one.records.filter((each) => each.purpose === "ownership")) lines.push(` publish ${record.type} ${record.name} ${record.value}`);
|
|
82635
82823
|
}
|
|
82824
|
+
lines.push(` ${publicationLine(one.publication)}`);
|
|
82636
82825
|
return lines.join("\n");
|
|
82637
82826
|
}
|
|
82827
|
+
/**
|
|
82828
|
+
* How far the public address has got, as the panel states it: the certificate and public activation are separate
|
|
82829
|
+
* observations, and no observation reads as unknown rather than as success.
|
|
82830
|
+
*/
|
|
82831
|
+
function publicationLine(publication) {
|
|
82832
|
+
if (publication == null) return "public address: unknown — no certificate or publication observation recorded yet";
|
|
82833
|
+
return `public address: ${publication.certificateReady ? "certificate ready" : "certificate not ready"}, ${publication.active ? `publicly active${publication.activeAt === null ? "" : ` since ${publication.activeAt}`}` : "not publicly active yet"}${publication.pendingReason === null ? "" : ` — ${publication.pendingReason}`}${publication.checkedAt === null ? "" : ` (observed ${publication.checkedAt})`}`;
|
|
82834
|
+
}
|
|
82638
82835
|
/** The `environment domain*`/`redirect*` renderer. */
|
|
82639
82836
|
function environmentDomainText(report) {
|
|
82640
82837
|
if (report.kind === "domain-write") {
|
|
@@ -82916,6 +83113,7 @@ function environmentText(report) {
|
|
|
82916
83113
|
` namespace ${report.namespace}`,
|
|
82917
83114
|
` cluster ${report.cluster.name}`,
|
|
82918
83115
|
` status ${report.status.status} generation ${String(report.status.generation)} applied ${String(report.status.appliedGeneration)}`,
|
|
83116
|
+
...statusStoryLines(report.status),
|
|
82919
83117
|
` observed ${report.status.observedAt ?? "never"}`,
|
|
82920
83118
|
` reconciled ${lastReconcile(report.lastReconcile)}`,
|
|
82921
83119
|
...allocationSummaryLines(report.allocationSummary)
|
|
@@ -82941,17 +83139,7 @@ function allocationSummaryLines(summary) {
|
|
|
82941
83139
|
function writeText$2(report) {
|
|
82942
83140
|
const receipt = renderWriteOutcome(report, outcomeOf$1);
|
|
82943
83141
|
if (!("readiness" in report) || report.readiness === void 0) return receipt;
|
|
82944
|
-
return `${receipt}\n${environmentText(report.readiness)}${statusMessage(report.readiness)}`;
|
|
82945
|
-
}
|
|
82946
|
-
/**
|
|
82947
|
-
* The platform's own message for the reading, when it wrote one.
|
|
82948
|
-
*
|
|
82949
|
-
* The status word says whether the generation was applied; the message is the only thing that says why not, so it is
|
|
82950
|
-
* printed rather than held back to the JSON answer.
|
|
82951
|
-
*/
|
|
82952
|
-
function statusMessage(environment) {
|
|
82953
|
-
const message = environment.status.message.trim();
|
|
82954
|
-
return message === "" ? "" : `\n message ${message}`;
|
|
83142
|
+
return `${receipt}\n${environmentText(report.readiness)}${statusMessage(report.readiness.status)}`;
|
|
82955
83143
|
}
|
|
82956
83144
|
/**
|
|
82957
83145
|
* The reference directory: one line per producer — its kind, its key, then what may be read from it.
|
|
@@ -83545,6 +83733,29 @@ var environments = {
|
|
|
83545
83733
|
return report.items.map((one) => ` ${one.uuid} ${one.slug.padEnd(width)} ${one.name} ${one.cluster.name}`).join("\n");
|
|
83546
83734
|
}
|
|
83547
83735
|
};
|
|
83736
|
+
// src/commands/provider-failure-text.ts
|
|
83737
|
+
/**
|
|
83738
|
+
* What each old-host failure means and what to do about it, in the words the panel uses. Keyed by the API's own
|
|
83739
|
+
* closed vocabulary, so a reason the API adds fails the type check here rather than printing as a bare slug.
|
|
83740
|
+
*/
|
|
83741
|
+
var FAILURE_SENTENCES = {
|
|
83742
|
+
"wrong-credentials": "The old host refused the login. Check the username, then replace the password.",
|
|
83743
|
+
"host-unreachable": "The old host did not answer. Check the address and port, and that the host accepts connections from outside.",
|
|
83744
|
+
"connection-limited": "The old host is limiting connections. Switch the connection to the gentle preset, then run it again.",
|
|
83745
|
+
"host-key-changed": "The server's host key changed since it was saved. Ask the old host whether that is expected; if it is, remove the connection and add it again.",
|
|
83746
|
+
"certificate-invalid": "The certificate does not match this address. Use the name the certificate is issued for as the address; verification is never skipped.",
|
|
83747
|
+
"path-not-found": "The start folder does not exist or this login cannot read it. Use a folder the login can open.",
|
|
83748
|
+
"not-enough-space": "The environment is short of space. Add storage to it, then run it again.",
|
|
83749
|
+
"private-address-refused": "The address points into a private network. Use the old host's public address.",
|
|
83750
|
+
unknown: "It failed for a reason the platform could not name. Run it again; if it repeats, contact support.",
|
|
83751
|
+
"not-enough-privileges": "The database login can read the database but cannot back it up: it lacks a privilege the backup needs, often SHOW VIEW or TRIGGER. Ask the old host to grant it, or use the database's main user.",
|
|
83752
|
+
"too-many-deletes": "This run stopped at its delete limit: the old host's folder is missing more files than the limit allows. Check it is the right folder, then raise the limit or run it again."
|
|
83753
|
+
};
|
|
83754
|
+
/** One failure as a sentence a person can act on, with the API's own reason kept for support and scripts. */
|
|
83755
|
+
function providerFailureSentence(reason) {
|
|
83756
|
+
const sentence = FAILURE_SENTENCES[reason];
|
|
83757
|
+
return sentence === void 0 ? reason : `${sentence} (${reason})`;
|
|
83758
|
+
}
|
|
83548
83759
|
// src/commands/files-import-schedule.ts
|
|
83549
83760
|
/** `--mirror` and its `--max-delete`, as the request fields; a copy takes neither. */
|
|
83550
83761
|
function mirrorFields(context) {
|
|
@@ -83600,9 +83811,9 @@ function scheduleLines(schedule) {
|
|
|
83600
83811
|
function runLines(one) {
|
|
83601
83812
|
if (one.runs.length === 0) return [];
|
|
83602
83813
|
return [" latest runs:", ...one.runs.map((run) => {
|
|
83603
|
-
const failure = run.failureReason === null ? "" :
|
|
83814
|
+
const failure = run.failureReason === null ? "" : `\n ${providerFailureSentence(run.failureReason)}`;
|
|
83604
83815
|
const kept = run.recoveryFolder === null ? "" : `\n ${recoveryFolderLine(run.recoveryFolder)}`;
|
|
83605
|
-
return ` ${run.uuid} ${run.state}
|
|
83816
|
+
return ` ${run.uuid} ${run.state} started ${run.createdAt}${failure}${kept}`;
|
|
83606
83817
|
})];
|
|
83607
83818
|
}
|
|
83608
83819
|
/** Where a mirror kept the files it replaced or deleted, and until when, in plain words. */
|
|
@@ -83819,7 +84030,7 @@ function progressLine(one) {
|
|
|
83819
84030
|
}
|
|
83820
84031
|
/** One import as a person reads it. */
|
|
83821
84032
|
function describeImport(one) {
|
|
83822
|
-
const failure = one.failureReason === null ? "" : `\n failed: ${one.failureReason}`;
|
|
84033
|
+
const failure = one.failureReason === null ? "" : `\n failed: ${providerFailureSentence(one.failureReason)}`;
|
|
83823
84034
|
const next = one.nextAttemptAt === null ? "" : `\n next attempt ${one.nextAttemptAt}`;
|
|
83824
84035
|
const cap = one.maxDelete === null ? "" : `\n deletes at most ${String(one.maxDelete)} files a run`;
|
|
83825
84036
|
return [
|
|
@@ -94059,7 +94270,7 @@ function writeUpdateState(state, env = process.env) {
|
|
|
94059
94270
|
} catch {}
|
|
94060
94271
|
}
|
|
94061
94272
|
// src/version.ts
|
|
94062
|
-
var VERSION = "1.0.
|
|
94273
|
+
var VERSION = "1.0.870";
|
|
94063
94274
|
// src/commands/update.ts
|
|
94064
94275
|
/**
|
|
94065
94276
|
* `update` — bring this copy of the CLI up to the published version.
|
|
@@ -94133,7 +94344,7 @@ var update = {
|
|
|
94133
94344
|
}, process.env);
|
|
94134
94345
|
return {
|
|
94135
94346
|
...known,
|
|
94136
|
-
current: after ?? "1.0.
|
|
94347
|
+
current: after ?? "1.0.870",
|
|
94137
94348
|
latest: after ?? latest,
|
|
94138
94349
|
upToDate: after !== null && (latest === null || !isNewerVersion(latest, after)),
|
|
94139
94350
|
action: "run",
|
|
@@ -94419,7 +94630,7 @@ async function printUpdateNotice(options) {
|
|
|
94419
94630
|
}, env, { waitMs: NOTICE_LOCK_WAIT_MS });
|
|
94420
94631
|
} catch {}
|
|
94421
94632
|
if (latest === null) return;
|
|
94422
|
-
if (!isNewerVersion(latest, "1.0.
|
|
94633
|
+
if (!isNewerVersion(latest, "1.0.870")) return;
|
|
94423
94634
|
process.stderr.write(`A newer hostingctl is published: ${latest} (this copy is ${VERSION}). Run \`hostingctl update\` to update.\n`);
|
|
94424
94635
|
}
|
|
94425
94636
|
/** Whether an environment variable is set to something, which is how CI and the opt-out are read. */
|