@haakco/hostingctl 1.0.865 → 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 +640 -217
- 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
|
@@ -37012,6 +37012,22 @@ function hostingSiteInsightsIncidents(options) {
|
|
|
37012
37012
|
}));
|
|
37013
37013
|
}
|
|
37014
37014
|
/**
|
|
37015
|
+
* {@link /c/:company/hosting/environments/:environmentUuid/site-insights/:siteUuid/page-rechecks/:recheckUuid}
|
|
37016
|
+
*/
|
|
37017
|
+
function hostingSiteInsightsPageRecheck(options) {
|
|
37018
|
+
const { client: request = client, ...config } = options;
|
|
37019
|
+
return withUnwrap(request({
|
|
37020
|
+
method: "GET",
|
|
37021
|
+
url: "/c/{company}/hosting/environments/{environmentUuid}/site-insights/{siteUuid}/page-rechecks/{recheckUuid}",
|
|
37022
|
+
security: [{
|
|
37023
|
+
type: "http",
|
|
37024
|
+
scheme: "bearer"
|
|
37025
|
+
}],
|
|
37026
|
+
...config,
|
|
37027
|
+
throwOnError: config.throwOnError ?? true
|
|
37028
|
+
}));
|
|
37029
|
+
}
|
|
37030
|
+
/**
|
|
37015
37031
|
* {@link /c/:company/hosting/environments/:environmentUuid/site-insights/:siteUuid/search/:provider}
|
|
37016
37032
|
*/
|
|
37017
37033
|
function hostingSiteInsightsConnectSearch(options) {
|
|
@@ -37093,6 +37109,23 @@ function hostingSiteInsightsAudit(options) {
|
|
|
37093
37109
|
}));
|
|
37094
37110
|
}
|
|
37095
37111
|
/**
|
|
37112
|
+
* {@link /c/:company/hosting/environments/:environmentUuid/site-insights/:siteUuid/page-rechecks}
|
|
37113
|
+
*/
|
|
37114
|
+
function hostingSiteInsightsRequestPageRecheck(options) {
|
|
37115
|
+
const { client: request = client, ...config } = options;
|
|
37116
|
+
return withUnwrap(request({
|
|
37117
|
+
method: "POST",
|
|
37118
|
+
url: "/c/{company}/hosting/environments/{environmentUuid}/site-insights/{siteUuid}/page-rechecks",
|
|
37119
|
+
security: [{
|
|
37120
|
+
type: "http",
|
|
37121
|
+
scheme: "bearer"
|
|
37122
|
+
}],
|
|
37123
|
+
contentType: { request: "application/json" },
|
|
37124
|
+
...config,
|
|
37125
|
+
throwOnError: config.throwOnError ?? true
|
|
37126
|
+
}));
|
|
37127
|
+
}
|
|
37128
|
+
/**
|
|
37096
37129
|
* {@link /c/:company/hosting/environments/:environmentUuid/site-insights/:siteUuid/fixes/:fix}
|
|
37097
37130
|
*/
|
|
37098
37131
|
function hostingSiteInsightsFix(options) {
|
|
@@ -44594,6 +44627,157 @@ function applicationAdminText(report) {
|
|
|
44594
44627
|
}
|
|
44595
44628
|
return recoveryLines$1(report.recovery).join("\n");
|
|
44596
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
|
+
}
|
|
44597
44781
|
// src/commands/application-build-log.ts
|
|
44598
44782
|
/** The line of the build's own output that the platform picked out as its failure. */
|
|
44599
44783
|
function buildErrorLine(error) {
|
|
@@ -44604,7 +44788,7 @@ function logText(log) {
|
|
|
44604
44788
|
return [
|
|
44605
44789
|
...log.error === null ? [] : [buildErrorLine(log.error)],
|
|
44606
44790
|
` build ${log.buildUuid} attempt ${String(log.attempt)} ${String(log.status)}${log.available ? "" : ` (log unavailable: ${log.detail})`}`,
|
|
44607
|
-
...
|
|
44791
|
+
...failureLines$1(log),
|
|
44608
44792
|
...log.truncated ? [" the log was truncated by the platform"] : [],
|
|
44609
44793
|
...log.contents === null ? [] : [log.contents]
|
|
44610
44794
|
].join("\n");
|
|
@@ -44697,7 +44881,7 @@ async function deliverApplicationSource(progress, path, key, archive, deadline,
|
|
|
44697
44881
|
uploadUuid: upload.uuid,
|
|
44698
44882
|
buildUuid: build.uuid
|
|
44699
44883
|
});
|
|
44700
|
-
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({
|
|
44701
44885
|
key,
|
|
44702
44886
|
workloadUuid: path.workloadUuid,
|
|
44703
44887
|
uploadUuid: upload.uuid,
|
|
@@ -44765,6 +44949,7 @@ async function awaitRelease(progress, path, key, releaseUuid, deadline) {
|
|
|
44765
44949
|
return running;
|
|
44766
44950
|
}
|
|
44767
44951
|
const release = observed.releases.find((one) => one.uuid === releaseUuid);
|
|
44952
|
+
if (release?.status === "failed") throw new ApiError(422, failedReleaseMessage(path, key, release));
|
|
44768
44953
|
const build = observed.builds.find((one) => one.uuid === release?.buildUuid);
|
|
44769
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\`.`);
|
|
44770
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})`}`);
|
|
@@ -44782,14 +44967,14 @@ function buildOf(deployment, uuid) {
|
|
|
44782
44967
|
* build failed on comes first, because it is the one a person acts on.
|
|
44783
44968
|
*/
|
|
44784
44969
|
async function buildRefusal(path, key, build, next) {
|
|
44785
|
-
const reason = [build.failureStage, build.failureReason].filter((one) => one !== null && one !== "");
|
|
44786
44970
|
const line = await failedBuildLine({
|
|
44787
44971
|
...path,
|
|
44788
44972
|
buildUuid: build.uuid
|
|
44789
44973
|
});
|
|
44790
44974
|
return new ApiError(422, [
|
|
44791
44975
|
...line === null ? [] : [line],
|
|
44792
|
-
`Build ${build.uuid} of application ${key} finished ${build.status}
|
|
44976
|
+
`Build ${build.uuid} of application ${key} finished ${build.status}.`,
|
|
44977
|
+
...failureLines$1(build),
|
|
44793
44978
|
next(build)
|
|
44794
44979
|
].join("\n"));
|
|
44795
44980
|
}
|
|
@@ -44826,7 +45011,7 @@ var BUILD_WAIT_DESCRIPTION = "Then wait for it and deploy its release once it su
|
|
|
44826
45011
|
async function waitForBuild(context, path, build, deadline) {
|
|
44827
45012
|
context.progress.start();
|
|
44828
45013
|
try {
|
|
44829
|
-
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)}\`.`);
|
|
44830
45015
|
return {
|
|
44831
45016
|
kind: "build-wait",
|
|
44832
45017
|
buildUuid: build.uuid,
|
|
@@ -45110,21 +45295,18 @@ function optionalFlag$1(context, flag) {
|
|
|
45110
45295
|
return value === "" ? null : value;
|
|
45111
45296
|
}
|
|
45112
45297
|
/** The write receipt: a build's own fields, or the deployment's source. */
|
|
45113
|
-
function writeText$6(report) {
|
|
45298
|
+
function writeText$6(report, path) {
|
|
45114
45299
|
const { outcome } = report;
|
|
45115
45300
|
if (!outcome.sent) return `Would: ${outcome.description}\nNothing was sent (--dry-run).`;
|
|
45116
45301
|
const value = outcome.result;
|
|
45117
|
-
if (typeof value.uuid === "string") {
|
|
45118
|
-
const failure = typeof value.failureReason === "string" ? ` — ${value.failureReason}` : "";
|
|
45119
|
-
return `${outcome.description}\n build ${value.uuid} ${String(value.status)}${failure}`;
|
|
45120
|
-
}
|
|
45302
|
+
if (typeof value.uuid === "string") return `${outcome.description}\n${buildText(outcome.result, path)}`;
|
|
45121
45303
|
const source = value.source;
|
|
45122
45304
|
return `${outcome.description}\n source ${source === null || source === void 0 ? "unbound" : source.branch ?? "detached"}`;
|
|
45123
45305
|
}
|
|
45124
45306
|
/** The `application build-*|source-*` renderer. */
|
|
45125
|
-
function applicationBuildText(report) {
|
|
45307
|
+
function applicationBuildText(report, path) {
|
|
45126
45308
|
if (report.kind === "build-wait") return buildWaitText(report);
|
|
45127
|
-
return report.kind === "build-write" ? writeText$6(report) : logText(report.log);
|
|
45309
|
+
return report.kind === "build-write" ? writeText$6(report, path) : logText(report.log);
|
|
45128
45310
|
}
|
|
45129
45311
|
// src/commands/application-cache-rules.ts
|
|
45130
45312
|
/** The `cache-set` flags that replace an application's ordered cache rules. */
|
|
@@ -45899,6 +46081,34 @@ function recoveryLines(one) {
|
|
|
45899
46081
|
` recovery ${one.uuid}`
|
|
45900
46082
|
].join("\n");
|
|
45901
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
|
+
}
|
|
45902
46112
|
// src/commands/application-capacity.ts
|
|
45903
46113
|
var CAPACITY_USAGE = [
|
|
45904
46114
|
"Usage: hostingctl application capacity <environment-uuid> <application-uuid> --company <slug> [--json]",
|
|
@@ -45924,7 +46134,8 @@ async function applicationCapacity(path) {
|
|
|
45924
46134
|
* The finding as the API stated it: the rung as a title, then the reason and the recommendation verbatim.
|
|
45925
46135
|
*
|
|
45926
46136
|
* A signal the platform could not read is named on its own line, because a rung that no measurement established
|
|
45927
|
-
* 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.
|
|
45928
46139
|
*/
|
|
45929
46140
|
function applicationCapacityText(finding) {
|
|
45930
46141
|
const { decision, signals } = finding;
|
|
@@ -45932,7 +46143,8 @@ function applicationCapacityText(finding) {
|
|
|
45932
46143
|
`${signals.application}: ${RUNG_TITLES[decision.rung]}`,
|
|
45933
46144
|
` reason ${decision.reason}`,
|
|
45934
46145
|
` next step ${decision.recommendation}`,
|
|
45935
|
-
...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)
|
|
45936
46148
|
].join("\n");
|
|
45937
46149
|
}
|
|
45938
46150
|
// src/commands/application-recovery-wait.ts
|
|
@@ -47460,55 +47672,6 @@ function schedulesText(schedules) {
|
|
|
47460
47672
|
return ` ${one.key} ${when} ${state} ${owner} last success ${one.lastSucceededAt ?? "never"} ${uses}`;
|
|
47461
47673
|
})].join("\n");
|
|
47462
47674
|
}
|
|
47463
|
-
// src/commands/application-image-text.ts
|
|
47464
|
-
/**
|
|
47465
|
-
* What an imported image release is, in the terminal's own lines.
|
|
47466
|
-
*
|
|
47467
|
-
* The panel renders the same provenance as prose; a terminal needs lines a person can compare, so the two
|
|
47468
|
-
* digests, the scan verdict and the architecture are one row each. Nothing here names an internal object
|
|
47469
|
-
* path, a registry credential or a connection secret.
|
|
47470
|
-
*/
|
|
47471
|
-
/** The scanner's answer, in the form a receipt states it. */
|
|
47472
|
-
function imageScanText(image) {
|
|
47473
|
-
const counts = `${String(image.scan.critical)} critical, ${String(image.scan.high)} high`;
|
|
47474
|
-
if (image.scan.status === "pending") return "pending — deployment unaffected";
|
|
47475
|
-
if (image.scan.status === "clean" || image.scan.status === "findings") return `completed — ${counts}`;
|
|
47476
|
-
return "unavailable — deployment unaffected";
|
|
47477
|
-
}
|
|
47478
|
-
/** The provenance lines for one imported image release, or none for a release built from source. */
|
|
47479
|
-
function imageProvenanceText(release) {
|
|
47480
|
-
const image = release.image;
|
|
47481
|
-
if (image === null) return [];
|
|
47482
|
-
const reference = image.sourceReference === "" ? image.sourceDigest : image.sourceReference;
|
|
47483
|
-
const separator = reference.startsWith("sha256:") ? "@" : ":";
|
|
47484
|
-
return [
|
|
47485
|
-
` image ${image.sourceHost}/${image.sourceRepository}${separator}${reference}`,
|
|
47486
|
-
` source digest ${image.sourceDigest}`,
|
|
47487
|
-
` stored digest ${image.internalDigest}`,
|
|
47488
|
-
` scan ${imageScanText(image)}`,
|
|
47489
|
-
` platform ${image.architecture}`
|
|
47490
|
-
];
|
|
47491
|
-
}
|
|
47492
|
-
/** The provenance of the release an application serves and of the one it is being asked to serve. */
|
|
47493
|
-
function deploymentImageText(releases) {
|
|
47494
|
-
return ["running", "requested"].flatMap((label) => {
|
|
47495
|
-
const release = releases[label];
|
|
47496
|
-
const lines = release === null ? [] : imageProvenanceText(release);
|
|
47497
|
-
return lines.length === 0 ? [] : [` ${label} image`, ...lines];
|
|
47498
|
-
});
|
|
47499
|
-
}
|
|
47500
|
-
/**
|
|
47501
|
-
* What preparing an image did, and what it has not done yet.
|
|
47502
|
-
*
|
|
47503
|
-
* Preparing records and verifies the import. Scanning is informational and does not delay readiness.
|
|
47504
|
-
* The receipt identifies the release to activate through the existing deployment operation. A deployment
|
|
47505
|
-
* receipt without a status still says it is preparing, rather than printing an empty column.
|
|
47506
|
-
*/
|
|
47507
|
-
function prepareImageText(result) {
|
|
47508
|
-
if (typeof result === "string") return ` ${result}`;
|
|
47509
|
-
const status = result.status === null || result.status === "" ? "preparing" : result.status;
|
|
47510
|
-
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");
|
|
47511
|
-
}
|
|
47512
47675
|
// src/commands/application-source-ssh-text.ts
|
|
47513
47676
|
/**
|
|
47514
47677
|
* One SSH source as a person needs it, whether it is serving or not.
|
|
@@ -47568,11 +47731,11 @@ function applicationSshSourceText(report) {
|
|
|
47568
47731
|
// src/commands/application-text.ts
|
|
47569
47732
|
/** The `application` group's human rendering, each answer read from the API's own payload. */
|
|
47570
47733
|
/** Each group tags its own answers, so the kind names the renderer. */
|
|
47571
|
-
function taggedText$1(report) {
|
|
47734
|
+
function taggedText$1(report, path) {
|
|
47572
47735
|
if (report.kind === "updates" || report.kind === "updates-write") return applicationUpdatesText(report);
|
|
47573
47736
|
if (report.kind === "runtime-version-move") return runtimeVersionMoveText(report);
|
|
47574
47737
|
if (report.kind === "cache" || report.kind === "routes" || report.kind === "cache-write") return applicationCacheText(report);
|
|
47575
|
-
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);
|
|
47576
47739
|
if (report.kind === "site-access" || report.kind === "site-users" || report.kind === "site-write") return siteAccessText(report);
|
|
47577
47740
|
if (report.kind === "import" || report.kind === "url-repair" || report.kind === "import-write") return applicationImportText(report);
|
|
47578
47741
|
if (report.kind === "recovery-review" || report.kind === "recovery-write" || report.kind === "recovery-wait") return applicationRecoveryText(report);
|
|
@@ -47596,16 +47759,17 @@ function sourceGroupText(report) {
|
|
|
47596
47759
|
}
|
|
47597
47760
|
}
|
|
47598
47761
|
function applicationText(report) {
|
|
47762
|
+
const path = applicationPathOf(report);
|
|
47599
47763
|
if ("anonymousKey" in report) return report.anonymousKey;
|
|
47600
47764
|
if ("measurement" in report) return applicationSpeedText(report);
|
|
47601
47765
|
if ("signals" in report) return applicationCapacityText(report);
|
|
47602
|
-
if ("kind" in report) return sourceGroupText(report) ?? taggedText$1(report);
|
|
47603
|
-
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));
|
|
47604
47768
|
if ("applications" in report) return listText(report);
|
|
47605
47769
|
if ("runs" in report) return runsText(report);
|
|
47606
47770
|
if ("output" in report) return runLogText(report);
|
|
47607
47771
|
if ("inventoryDigest" in report) return removalReviewText(report);
|
|
47608
|
-
if ("builds" in report) return deploymentText(report);
|
|
47772
|
+
if ("builds" in report) return deploymentText(report, path);
|
|
47609
47773
|
if ("replicas" in report) return applicationDetailText(report);
|
|
47610
47774
|
return "";
|
|
47611
47775
|
}
|
|
@@ -47638,9 +47802,9 @@ function runtimeVersionText(app) {
|
|
|
47638
47802
|
const serving = app.runtimeVersionEffective ?? null;
|
|
47639
47803
|
return serving === null || serving === desired ? desired : `${desired} requested, ${serving} serving`;
|
|
47640
47804
|
}
|
|
47641
|
-
function deploymentText(data) {
|
|
47805
|
+
function deploymentText(data, path) {
|
|
47642
47806
|
const running = data.running === null ? "none" : `${data.running.uuid} (sequence ${String(data.running.sequence)})`;
|
|
47643
|
-
const requested = data.requested === null ? "none" : data.requested.uuid
|
|
47807
|
+
const requested = data.requested === null ? "none" : `${data.requested.uuid} (${data.requested.status})`;
|
|
47644
47808
|
const interrupted = data.interrupted === null ? "none" : `build ${data.interrupted.uuid} (${data.interrupted.status})`;
|
|
47645
47809
|
return [
|
|
47646
47810
|
` running ${running}`,
|
|
@@ -47653,12 +47817,10 @@ function deploymentText(data) {
|
|
|
47653
47817
|
...deploymentImageText({
|
|
47654
47818
|
running: data.running,
|
|
47655
47819
|
requested: data.requested
|
|
47656
|
-
})
|
|
47820
|
+
}),
|
|
47821
|
+
...deploymentFailureLines(data, path)
|
|
47657
47822
|
].join("\n");
|
|
47658
47823
|
}
|
|
47659
|
-
function buildText(build) {
|
|
47660
|
-
return [` build ${build.uuid} attempt ${String(build.attempt)} ${build.status}`, ` stage ${build.failureStage ?? "—"} ${build.failureReason ?? ""}`.trimEnd()].join("\n");
|
|
47661
|
-
}
|
|
47662
47824
|
function runsText(data) {
|
|
47663
47825
|
if (data.source === "unavailable") return `Process run history is unavailable: ${data.detail}`;
|
|
47664
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");
|
|
@@ -47685,19 +47847,15 @@ function createText(report) {
|
|
|
47685
47847
|
return `${outcome.description}\n${applicationDetailText(outcome.result)}`;
|
|
47686
47848
|
}
|
|
47687
47849
|
/** The write receipt, answering the API's own message when that is what came back. */
|
|
47688
|
-
function writeAnyResultText(result) {
|
|
47850
|
+
function writeAnyResultText(result, path) {
|
|
47689
47851
|
const value = result;
|
|
47690
47852
|
if (typeof value.message === "string" && typeof value.uuid !== "string") return ` ${value.message}`;
|
|
47691
|
-
return writeResultText$1(result);
|
|
47853
|
+
return writeResultText$1(result, path);
|
|
47692
47854
|
}
|
|
47693
|
-
function writeResultText$1(result) {
|
|
47694
|
-
if ("failureStage" in result) return buildText(result);
|
|
47855
|
+
function writeResultText$1(result, path) {
|
|
47856
|
+
if ("failureStage" in result) return buildText(result, path);
|
|
47695
47857
|
if ("releaseUuid" in result) return prepareImageText(result);
|
|
47696
|
-
if ("imageDigest" in result) return
|
|
47697
|
-
` release ${result.uuid} ${result.status} running ${result.isRunning ? "yes" : "no"}`,
|
|
47698
|
-
...result.deployWaiting ? [" will deploy when the current change finishes"] : [],
|
|
47699
|
-
...imageProvenanceText(result)
|
|
47700
|
-
].join("\n");
|
|
47858
|
+
if ("imageDigest" in result) return releaseText(result);
|
|
47701
47859
|
if ("runToken" in result) return ` ${result.message}`;
|
|
47702
47860
|
if ("statusName" in result) return ` removal ${result.uuid} ${result.statusName} open ${result.isOpen ? "yes" : "no"}`;
|
|
47703
47861
|
return applicationDetailText(result);
|
|
@@ -47734,11 +47892,12 @@ async function journey(context) {
|
|
|
47734
47892
|
environmentUuid
|
|
47735
47893
|
}, [workloadUuid, ...extra].filter((one) => one !== void 0));
|
|
47736
47894
|
if (workloadUuid === void 0) throw new UsageError(APPLICATION_USAGE);
|
|
47737
|
-
|
|
47895
|
+
const path = {
|
|
47738
47896
|
company,
|
|
47739
47897
|
environmentUuid,
|
|
47740
47898
|
workloadUuid
|
|
47741
|
-
}
|
|
47899
|
+
};
|
|
47900
|
+
return rememberApplicationPath(await dispatched$2(context, action, path, extra), path);
|
|
47742
47901
|
}
|
|
47743
47902
|
/** The actions that name one application, once its path is resolved. */
|
|
47744
47903
|
async function dispatched$2(context, action, path, extra) {
|
|
@@ -48536,7 +48695,17 @@ var createHostingDatabaseRequestExtensionsEnum = {
|
|
|
48536
48695
|
autoinc: "autoinc",
|
|
48537
48696
|
insert_username: "insert_username",
|
|
48538
48697
|
moddatetime: "moddatetime",
|
|
48539
|
-
refint: "refint"
|
|
48698
|
+
refint: "refint",
|
|
48699
|
+
pgfaceting: "pgfaceting",
|
|
48700
|
+
pg_partman: "pg_partman",
|
|
48701
|
+
zson: "zson",
|
|
48702
|
+
pgmq: "pgmq",
|
|
48703
|
+
postgis_topology: "postgis_topology",
|
|
48704
|
+
address_standardizer_data_us: "address_standardizer_data_us",
|
|
48705
|
+
pointcloud: "pointcloud",
|
|
48706
|
+
pointcloud_postgis: "pointcloud_postgis",
|
|
48707
|
+
amcheck: "amcheck",
|
|
48708
|
+
pg_background: "pg_background"
|
|
48540
48709
|
};
|
|
48541
48710
|
var hostingWorkloadEnum = {
|
|
48542
48711
|
wordpress: "wordpress",
|
|
@@ -55725,7 +55894,7 @@ var billingAmountBasisEnumSchema = _enum([
|
|
|
55725
55894
|
"per_month",
|
|
55726
55895
|
"once_off",
|
|
55727
55896
|
"per_month_including_vat"
|
|
55728
|
-
]).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");
|
|
55729
55898
|
var billingAmountsDataSchema = object({
|
|
55730
55899
|
netCents: int(),
|
|
55731
55900
|
vatCents: int(),
|
|
@@ -55772,13 +55941,13 @@ var billingCollectionReceiptStateEnumSchema = _enum([
|
|
|
55772
55941
|
"allocated",
|
|
55773
55942
|
"unallocated",
|
|
55774
55943
|
"reversed"
|
|
55775
|
-
]).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. |");
|
|
55776
55945
|
var billingCollectionReceiptDataSchema = object({
|
|
55777
55946
|
uuid: string(),
|
|
55778
55947
|
amountCents: int(),
|
|
55779
55948
|
currency: string(),
|
|
55780
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"),
|
|
55781
|
-
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. |"),
|
|
55782
55951
|
receivedAt: string(),
|
|
55783
55952
|
allocatedAt: string().nullable(),
|
|
55784
55953
|
reversedAt: string().nullable(),
|
|
@@ -55868,10 +56037,10 @@ var billingCreditEntryTypeEnumSchema = _enum([
|
|
|
55868
56037
|
"refunded_to_customer",
|
|
55869
56038
|
"applied_to_invoice",
|
|
55870
56039
|
"application_reversed"
|
|
55871
|
-
]).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");
|
|
55872
56041
|
var billingCreditLedgerEntryDataSchema = object({
|
|
55873
56042
|
uuid: string(),
|
|
55874
|
-
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"),
|
|
55875
56044
|
amountCents: int(),
|
|
55876
56045
|
currency: string(),
|
|
55877
56046
|
occurredAt: string(),
|
|
@@ -55980,7 +56149,7 @@ var billingVendorStatusEnumSchema = _enum([
|
|
|
55980
56149
|
"not_registered",
|
|
55981
56150
|
"registered"
|
|
55982
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");
|
|
55983
|
-
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. |");
|
|
55984
56153
|
var billingIssueEligibilityGapDataSchema = object({
|
|
55985
56154
|
particular: string(),
|
|
55986
56155
|
message: string()
|
|
@@ -56000,17 +56169,17 @@ object({
|
|
|
56000
56169
|
postalCode: string().nullable(),
|
|
56001
56170
|
countryCode: string().nullable(),
|
|
56002
56171
|
dueDays: int().nullable(),
|
|
56003
|
-
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. |"),
|
|
56004
56173
|
fullInvoiceGaps: array(billingIssueEligibilityGapDataSchema)
|
|
56005
56174
|
});
|
|
56006
56175
|
var billingDeliveryStateEnumSchema = _enum([
|
|
56007
56176
|
"not_sent",
|
|
56008
56177
|
"sent",
|
|
56009
56178
|
"failed"
|
|
56010
|
-
]).describe("What we know about sending the document. The mail transport can prove submission, not mailbox delivery, so `sent` means \"the transport
|
|
56011
|
-
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");
|
|
56012
56181
|
var billingDiscountCodeRedemptionDataSchema = object({
|
|
56013
|
-
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. |"),
|
|
56014
56183
|
code: string(),
|
|
56015
56184
|
companySlug: string(),
|
|
56016
56185
|
amountCents: int().nullable(),
|
|
@@ -56023,7 +56192,7 @@ var billingDiscountCodeRedemptionDataSchema = object({
|
|
|
56023
56192
|
var billingDiscountCodeDataSchema = object({
|
|
56024
56193
|
uuid: string(),
|
|
56025
56194
|
code: string(),
|
|
56026
|
-
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"),
|
|
56027
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"),
|
|
56028
56197
|
packageKey: string().nullable(),
|
|
56029
56198
|
amountCents: int().nullable(),
|
|
@@ -56158,7 +56327,7 @@ var billingInvoiceDataSchema = object({
|
|
|
56158
56327
|
storageFailureReason: string().nullable(),
|
|
56159
56328
|
pdfChecksum: string().nullable(),
|
|
56160
56329
|
pdfVerifiedAt: string().nullable(),
|
|
56161
|
-
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"),
|
|
56162
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"),
|
|
56163
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")
|
|
56164
56333
|
});
|
|
@@ -56178,7 +56347,7 @@ object({
|
|
|
56178
56347
|
issuedAt: string().nullable(),
|
|
56179
56348
|
voidedAt: string().nullable(),
|
|
56180
56349
|
voidReason: string().nullable(),
|
|
56181
|
-
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"),
|
|
56182
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"),
|
|
56183
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")
|
|
56184
56353
|
})),
|
|
@@ -56286,7 +56455,7 @@ var billingRateExistingCustomerRuleEnumSchema = _enum(["grandfathered", "applies
|
|
|
56286
56455
|
object({
|
|
56287
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"),
|
|
56288
56457
|
packageKey: string(),
|
|
56289
|
-
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"),
|
|
56290
56459
|
currentAmountCents: int(),
|
|
56291
56460
|
newAmountCents: int(),
|
|
56292
56461
|
isIncrease: boolean(),
|
|
@@ -56343,7 +56512,7 @@ object({ items: array(object({
|
|
|
56343
56512
|
companySlug: string().nullable(),
|
|
56344
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"),
|
|
56345
56514
|
packageKey: string().nullable(),
|
|
56346
|
-
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"),
|
|
56347
56516
|
amountCents: int(),
|
|
56348
56517
|
currency: string(),
|
|
56349
56518
|
effectiveFrom: string(),
|
|
@@ -56489,7 +56658,7 @@ var hostingSourceKindEnumSchema = _enum([
|
|
|
56489
56658
|
"upload",
|
|
56490
56659
|
"ssh"
|
|
56491
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");
|
|
56492
|
-
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. |");
|
|
56493
56662
|
var bindHostingApplicationSourceRequestSchema = object({
|
|
56494
56663
|
sourceKind: union([hostingSourceKindEnumSchema, _null()]).optional(),
|
|
56495
56664
|
repositorySelectionUuid: uuid().nullish(),
|
|
@@ -56561,7 +56730,7 @@ var permissionSchema = _enum([
|
|
|
56561
56730
|
"platform.billing.write_off",
|
|
56562
56731
|
"billing.view",
|
|
56563
56732
|
"billing.profile.manage"
|
|
56564
|
-
]).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/> |");
|
|
56565
56734
|
var companySummaryDataSchema = object({
|
|
56566
56735
|
slug: string(),
|
|
56567
56736
|
name: string(),
|
|
@@ -57089,17 +57258,17 @@ var createHostingApplicationRequestSchema = object({
|
|
|
57089
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."),
|
|
57090
57259
|
desiredGeneration: int().min(0)
|
|
57091
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.");
|
|
57092
|
-
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");
|
|
57093
57262
|
object({
|
|
57094
57263
|
sourceWorkloadUuid: uuid(),
|
|
57095
57264
|
targetWorkloadUuid: uuid(),
|
|
57096
57265
|
domainUuid: uuid().nullish(),
|
|
57097
57266
|
path: string().max(255),
|
|
57098
57267
|
canonical: boolean().optional(),
|
|
57099
|
-
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"),
|
|
57100
57269
|
desiredGeneration: int().min(1)
|
|
57101
57270
|
});
|
|
57102
|
-
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");
|
|
57103
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");
|
|
57104
57273
|
var createHostingCancellationRequestSchema = object({
|
|
57105
57274
|
reason: string().min(4).max(2e3),
|
|
@@ -57192,7 +57361,17 @@ var createHostingDatabaseRequestSchema = object({
|
|
|
57192
57361
|
"autoinc",
|
|
57193
57362
|
"insert_username",
|
|
57194
57363
|
"moddatetime",
|
|
57195
|
-
"refint"
|
|
57364
|
+
"refint",
|
|
57365
|
+
"pgfaceting",
|
|
57366
|
+
"pg_partman",
|
|
57367
|
+
"zson",
|
|
57368
|
+
"pgmq",
|
|
57369
|
+
"postgis_topology",
|
|
57370
|
+
"address_standardizer_data_us",
|
|
57371
|
+
"pointcloud",
|
|
57372
|
+
"pointcloud_postgis",
|
|
57373
|
+
"amcheck",
|
|
57374
|
+
"pg_background"
|
|
57196
57375
|
])).max(16).refine((items) => new Set(items).size === items.length, { message: "Array entries must be unique" }).optional().describe("PostgreSQL extensions. Validated against the catalogue that knows what each one needs to be\nloaded, so a name that would be silently ignored is refused instead."),
|
|
57197
57376
|
bindings: array(uuid()).max(16).refine((items) => new Set(items).size === items.length, { message: "Array entries must be unique" }).optional(),
|
|
57198
57377
|
applicationUuid: string().optional()
|
|
@@ -57213,7 +57392,7 @@ var hostingVolumeEnumSchema = _enum([
|
|
|
57213
57392
|
"database-data",
|
|
57214
57393
|
"redis-data"
|
|
57215
57394
|
]);
|
|
57216
|
-
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. |");
|
|
57217
57396
|
var createHostingEnvironmentRequestSchema = object({
|
|
57218
57397
|
certificateIssuer: hostingCertificateIssuerEnumSchema.optional(),
|
|
57219
57398
|
mode: hostingEnvironmentModeEnumSchema.optional(),
|
|
@@ -57245,7 +57424,7 @@ var createHostingEnvironmentRequestSchema = object({
|
|
|
57245
57424
|
name: string().max(100),
|
|
57246
57425
|
webServer: string().max(32).nullish(),
|
|
57247
57426
|
runtimeVersion: string().max(16).nullish(),
|
|
57248
|
-
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. |"),
|
|
57249
57428
|
replicas: int().min(1),
|
|
57250
57429
|
resources: object({
|
|
57251
57430
|
cpuRequestMillicores: int().min(1),
|
|
@@ -57860,7 +58039,7 @@ var emailRecipientRouteStateDataSchema = object({
|
|
|
57860
58039
|
"local",
|
|
57861
58040
|
"foreign",
|
|
57862
58041
|
"unobserved"
|
|
57863
|
-
]).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. |"),
|
|
57864
58043
|
target: string().nullable(),
|
|
57865
58044
|
observedAt: string()
|
|
57866
58045
|
});
|
|
@@ -58237,12 +58416,40 @@ var hostingAccessConnectionDataSchema = object({
|
|
|
58237
58416
|
fingerprintCommand: string().nullable(),
|
|
58238
58417
|
note: string()
|
|
58239
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
|
+
});
|
|
58240
58446
|
var hostingEnvironmentStatusDataSchema = object({
|
|
58241
58447
|
status: string(),
|
|
58242
58448
|
generation: int(),
|
|
58243
58449
|
appliedGeneration: int(),
|
|
58244
58450
|
message: string(),
|
|
58245
|
-
observedAt: string().nullable()
|
|
58451
|
+
observedAt: string().nullable(),
|
|
58452
|
+
explanation: union([hostingFailureExplanationDataSchema, _null()])
|
|
58246
58453
|
});
|
|
58247
58454
|
var hostingDeploymentIdentityAccessDataSchema = object({
|
|
58248
58455
|
siteUserUuid: string(),
|
|
@@ -58942,11 +59149,11 @@ var hostingRestoreCheckOutcomeEnumSchema = _enum([
|
|
|
58942
59149
|
"refused",
|
|
58943
59150
|
"unavailable",
|
|
58944
59151
|
"deferred"
|
|
58945
|
-
]).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. |");
|
|
58946
59153
|
var hostingRestoreIntakeCheckDataSchema = object({
|
|
58947
59154
|
key: string(),
|
|
58948
59155
|
label: string(),
|
|
58949
|
-
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. |"),
|
|
58950
59157
|
measured: string(),
|
|
58951
59158
|
required: string(),
|
|
58952
59159
|
detail: string()
|
|
@@ -59001,19 +59208,38 @@ var hostingApplicationRecoveryReviewDataSchema = object({
|
|
|
59001
59208
|
blockedReason: string().nullable(),
|
|
59002
59209
|
recovery: union([hostingApplicationRecoveryDataSchema, _null()])
|
|
59003
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
|
+
});
|
|
59004
59241
|
object({
|
|
59005
|
-
decision:
|
|
59006
|
-
rung: _enum([
|
|
59007
|
-
"healthy",
|
|
59008
|
-
"unmeasured",
|
|
59009
|
-
"warn",
|
|
59010
|
-
"throttle",
|
|
59011
|
-
"memory",
|
|
59012
|
-
"oom"
|
|
59013
|
-
]).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"),
|
|
59014
|
-
reason: string(),
|
|
59015
|
-
recommendation: string()
|
|
59016
|
-
}),
|
|
59242
|
+
decision: hostingApplicationRedLineDecisionDataSchema,
|
|
59017
59243
|
signals: object({
|
|
59018
59244
|
tenant: string(),
|
|
59019
59245
|
environment: string(),
|
|
@@ -59024,7 +59250,8 @@ object({
|
|
|
59024
59250
|
oomKills: int().nullable(),
|
|
59025
59251
|
cpuCommittedRatio: number(),
|
|
59026
59252
|
memoryCommittedRatio: number(),
|
|
59027
|
-
unmeasured: array(string())
|
|
59253
|
+
unmeasured: array(string()),
|
|
59254
|
+
containerIssues: array(hostingContainerIssueDataSchema).nullable()
|
|
59028
59255
|
})
|
|
59029
59256
|
});
|
|
59030
59257
|
var hostingApplicationRemovalDataSchema = object({
|
|
@@ -59067,7 +59294,7 @@ var hostingApplicationRouteDataSchema = object({
|
|
|
59067
59294
|
path: string(),
|
|
59068
59295
|
url: string().nullable(),
|
|
59069
59296
|
canonical: boolean(),
|
|
59070
|
-
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")
|
|
59071
59298
|
});
|
|
59072
59299
|
object({
|
|
59073
59300
|
environmentUuid: string(),
|
|
@@ -59083,7 +59310,7 @@ var hostingAutoDeployVerdictDataSchema = object({
|
|
|
59083
59310
|
"stale",
|
|
59084
59311
|
"no_event_revision",
|
|
59085
59312
|
"undecidable"
|
|
59086
|
-
]).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\". |"),
|
|
59087
59314
|
eventRevision: string().nullable().describe("The revision the push named, abbreviated, or null when the delivery carried none."),
|
|
59088
59315
|
deployedRevision: string().nullable().describe("The revision serving when the decision was drawn, abbreviated, or null when none served."),
|
|
59089
59316
|
explanation: string().describe("What the outcome means for this push, in one sentence."),
|
|
@@ -59155,30 +59382,6 @@ var hostingBudgetMemberKindEnumSchema = _enum([
|
|
|
59155
59382
|
"application",
|
|
59156
59383
|
"database"
|
|
59157
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");
|
|
59158
|
-
var hostingFailureCauseEnumSchema = _enum([
|
|
59159
|
-
"source-not-reachable",
|
|
59160
|
-
"commit-not-found",
|
|
59161
|
-
"recipe-refusal",
|
|
59162
|
-
"build-timeout",
|
|
59163
|
-
"build-command-failed",
|
|
59164
|
-
"worker-never-reported",
|
|
59165
|
-
"image-unavailable",
|
|
59166
|
-
"dependency-unsatisfied",
|
|
59167
|
-
"release-task-failed",
|
|
59168
|
-
"validation-refusal",
|
|
59169
|
-
"kubernetes-refusal",
|
|
59170
|
-
"resource-conflict",
|
|
59171
|
-
"transient-transport",
|
|
59172
|
-
"unclassified"
|
|
59173
|
-
]).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");
|
|
59174
|
-
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");
|
|
59175
|
-
var hostingFailureExplanationDataSchema = object({
|
|
59176
|
-
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"),
|
|
59177
|
-
message: string(),
|
|
59178
|
-
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"),
|
|
59179
|
-
nextAction: string().nullable(),
|
|
59180
|
-
retryable: boolean()
|
|
59181
|
-
});
|
|
59182
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");
|
|
59183
59386
|
var hostingBuildDataSchema = object({
|
|
59184
59387
|
uuid: string(),
|
|
@@ -59251,13 +59454,13 @@ var hostingCacheRuleActionEnumSchema = _enum([
|
|
|
59251
59454
|
"respect_origin",
|
|
59252
59455
|
"public_assets",
|
|
59253
59456
|
"public_pages"
|
|
59254
|
-
]).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.
|
|
59255
|
-
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");
|
|
59256
59459
|
var hostingCacheRuleDataSchema = object({
|
|
59257
59460
|
label: string(),
|
|
59258
|
-
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"),
|
|
59259
59462
|
path: string(),
|
|
59260
|
-
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"),
|
|
59261
59464
|
enabled: boolean(),
|
|
59262
59465
|
hostname: string().nullable(),
|
|
59263
59466
|
freshSeconds: int(),
|
|
@@ -59290,7 +59493,7 @@ var hostingRestorePointStateEnumSchema = _enum([
|
|
|
59290
59493
|
"observed",
|
|
59291
59494
|
"none_found",
|
|
59292
59495
|
"unconfirmed"
|
|
59293
|
-
]).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");
|
|
59294
59497
|
var hostingCancellationTargetDataSchema = object({
|
|
59295
59498
|
workloadUuid: string(),
|
|
59296
59499
|
name: string(),
|
|
@@ -59324,7 +59527,7 @@ var hostingCancellationReviewDataSchema = object({
|
|
|
59324
59527
|
namespace: string(),
|
|
59325
59528
|
serviceEndsAt: string(),
|
|
59326
59529
|
dataRecoverableUntil: string(),
|
|
59327
|
-
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"),
|
|
59328
59531
|
restorePointObservedAt: string().nullable(),
|
|
59329
59532
|
restorePointCheckedAt: string().nullable(),
|
|
59330
59533
|
earliestServiceEndsAt: string(),
|
|
@@ -59630,7 +59833,7 @@ var hostingConfigurationRouteDataSchema = object({
|
|
|
59630
59833
|
source: string(),
|
|
59631
59834
|
target: string(),
|
|
59632
59835
|
path: string(),
|
|
59633
|
-
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"),
|
|
59634
59837
|
canonical: boolean()
|
|
59635
59838
|
});
|
|
59636
59839
|
var hostingConfigurationDataSchema = object({
|
|
@@ -59964,7 +60167,7 @@ var hostingDatabaseDataMigrationPeerBindingsDataSchema = object({ bindings: arra
|
|
|
59964
60167
|
canonicalClaimUid: string().nullable(),
|
|
59965
60168
|
destinationControllerUid: string().nullable()
|
|
59966
60169
|
})) });
|
|
59967
|
-
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");
|
|
59968
60171
|
var hostingStorageClassDataSchema = object({
|
|
59969
60172
|
uuid: string(),
|
|
59970
60173
|
clusterUuid: string(),
|
|
@@ -60011,7 +60214,7 @@ var hostingDatabaseDataMigrationReviewDataSchema = object({
|
|
|
60011
60214
|
sourcePvName: string(),
|
|
60012
60215
|
sourcePvUid: string(),
|
|
60013
60216
|
sourceProvisioner: string(),
|
|
60014
|
-
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"),
|
|
60015
60218
|
sourceCsiDriver: string().nullable(),
|
|
60016
60219
|
sourceVolumeHandle: string().nullable(),
|
|
60017
60220
|
sourceCsiClusterId: string().nullable(),
|
|
@@ -60037,22 +60240,22 @@ var hostingDatabaseExportFormatEnumSchema = _enum([
|
|
|
60037
60240
|
"sql-gzip",
|
|
60038
60241
|
"pg-custom",
|
|
60039
60242
|
"tar-gzip"
|
|
60040
|
-
]).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/> |");
|
|
60041
60244
|
var hostingDatabaseExportStatusEnumSchema = _enum([
|
|
60042
60245
|
"queued",
|
|
60043
60246
|
"running",
|
|
60044
60247
|
"succeeded",
|
|
60045
60248
|
"failed",
|
|
60046
60249
|
"expired"
|
|
60047
|
-
]).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. |");
|
|
60048
60251
|
var hostingDatabaseExportDataSchema = object({
|
|
60049
60252
|
uuid: string(),
|
|
60050
60253
|
databaseUuid: string().nullable(),
|
|
60051
60254
|
databaseName: string().nullable(),
|
|
60052
60255
|
application: string().nullable(),
|
|
60053
60256
|
engine: union([hostingWorkloadEnumSchema, _null()]),
|
|
60054
|
-
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/>
|
|
60055
|
-
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. |"),
|
|
60056
60259
|
sizeBytes: int().nullable(),
|
|
60057
60260
|
failureReason: string().nullable(),
|
|
60058
60261
|
requestedAt: datetime(),
|
|
@@ -60069,7 +60272,7 @@ var hostingDatabaseExportDataSchema = object({
|
|
|
60069
60272
|
object({
|
|
60070
60273
|
url: string(),
|
|
60071
60274
|
fileName: string(),
|
|
60072
|
-
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/> |"),
|
|
60073
60276
|
restoreTool: string(),
|
|
60074
60277
|
expiresAt: datetime()
|
|
60075
60278
|
});
|
|
@@ -60166,13 +60369,13 @@ var hostingReleaseArtifactCompatibilityEnumSchema = _enum([
|
|
|
60166
60369
|
"paired",
|
|
60167
60370
|
"no_frontend_artifact",
|
|
60168
60371
|
"mismatched"
|
|
60169
|
-
]).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. |");
|
|
60170
60373
|
var hostingReleaseArtifactSetDataSchema = object({
|
|
60171
60374
|
releaseUuid: string(),
|
|
60172
60375
|
backendProcessDigest: string().nullable().describe("The immutable digest the backend processes run, or null when the release records none."),
|
|
60173
60376
|
frontendArtifactDigest: string().nullable().describe("The immutable application bundle that serves the frontend, or null for an image-only release."),
|
|
60174
60377
|
frontendBuiltForDigest: string().nullable().describe("The runtime image the frontend artifact was built for, as the bundle records it."),
|
|
60175
|
-
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. |"),
|
|
60176
60379
|
explanation: string().describe("The pairing's own sentence, so the reason a reader sees is the reason the platform decided.")
|
|
60177
60380
|
});
|
|
60178
60381
|
var hostingRetainedBuildLogDataSchema = object({
|
|
@@ -60201,6 +60404,10 @@ var hostingReleaseHttpProbeDataSchema = object({
|
|
|
60201
60404
|
readinessFailureThreshold: int(),
|
|
60202
60405
|
protocol: hostingClientImageProtocolEnumSchema.describe("What a client image's listener speaks (`run.protocol`, schema 1.25). The value is the URL scheme a reference hands to the application that reads it (`{service: db, field: url}` → `postgres://host:port`), and it decides exposure: only `http` is routed; every other protocol is private, reached only by the applications that reference it, and checked for readiness by a TCP connect instead of an HTTP path. The schema enum and this enum are the same list.\n")
|
|
60203
60406
|
});
|
|
60407
|
+
var hostingImageUserDataSchema = object({
|
|
60408
|
+
uid: int(),
|
|
60409
|
+
gid: int()
|
|
60410
|
+
});
|
|
60204
60411
|
var hostingReleaseImageDataSchema = object({
|
|
60205
60412
|
connectionUuid: string(),
|
|
60206
60413
|
connectionVersion: int(),
|
|
@@ -60217,7 +60424,8 @@ var hostingReleaseImageDataSchema = object({
|
|
|
60217
60424
|
importedAt: datetime().nullable(),
|
|
60218
60425
|
sourceReference: string(),
|
|
60219
60426
|
httpProbe: union([hostingReleaseHttpProbeDataSchema, _null()]),
|
|
60220
|
-
user: string().nullable()
|
|
60427
|
+
user: string().nullable(),
|
|
60428
|
+
identity: union([hostingImageUserDataSchema, _null()])
|
|
60221
60429
|
});
|
|
60222
60430
|
var hostingReleaseDataSchema = object({
|
|
60223
60431
|
uuid: string(),
|
|
@@ -60490,7 +60698,7 @@ var hostingServiceIncidentDataSchema = object({
|
|
|
60490
60698
|
"no_database_declared",
|
|
60491
60699
|
"extension_missing",
|
|
60492
60700
|
"unanswered"
|
|
60493
|
-
]).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()]),
|
|
60494
60702
|
summary: string().describe("The impact in plain language, safe to show a client."),
|
|
60495
60703
|
openedAt: string().describe("ISO-8601 UTC instant the outage was confirmed."),
|
|
60496
60704
|
lastObservedAt: string().describe("ISO-8601 UTC instant the platform last looked at the resource.")
|
|
@@ -60512,7 +60720,7 @@ var hostingProfileCoverageDataSchema = object({
|
|
|
60512
60720
|
"complete",
|
|
60513
60721
|
"short_of_catalog",
|
|
60514
60722
|
"not_participating"
|
|
60515
|
-
]).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"),
|
|
60516
60724
|
present: int(),
|
|
60517
60725
|
expected: int(),
|
|
60518
60726
|
missing: array(hostingMissingComponentDataSchema)
|
|
@@ -60653,13 +60861,13 @@ var hostingExportSourceDataSchema = object({
|
|
|
60653
60861
|
databaseUuid: string().nullable(),
|
|
60654
60862
|
capturedAt: datetime(),
|
|
60655
60863
|
expiresAt: datetime(),
|
|
60656
|
-
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/> |"),
|
|
60657
60865
|
restoreTool: string(),
|
|
60658
60866
|
scopeLabel: string()
|
|
60659
60867
|
});
|
|
60660
60868
|
object({
|
|
60661
60869
|
environmentUuid: string(),
|
|
60662
|
-
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. |"),
|
|
60663
60871
|
sources: array(hostingExportSourceDataSchema),
|
|
60664
60872
|
failureReason: string().nullable()
|
|
60665
60873
|
});
|
|
@@ -60964,10 +61172,10 @@ var hostingMailRelayDiagnosisStepStatusEnumSchema = _enum([
|
|
|
60964
61172
|
"passed",
|
|
60965
61173
|
"failed",
|
|
60966
61174
|
"not_reached"
|
|
60967
|
-
]).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. |");
|
|
60968
61176
|
var hostingMailRelayDiagnosisStepDataSchema = object({
|
|
60969
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. |"),
|
|
60970
|
-
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. |"),
|
|
60971
61179
|
detail: string().describe("What was found, in words, with the server's own answer when it refused. Never a credential.")
|
|
60972
61180
|
});
|
|
60973
61181
|
var hostingMailRelayDiagnosisLineDataSchema = object({
|
|
@@ -61055,7 +61263,7 @@ var hostingOperationKindEnumSchema = _enum([
|
|
|
61055
61263
|
"update",
|
|
61056
61264
|
"restore",
|
|
61057
61265
|
"backup"
|
|
61058
|
-
]).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");
|
|
61059
61267
|
var hostingOperationPhaseStatisticDataSchema = object({
|
|
61060
61268
|
stepKey: string(),
|
|
61061
61269
|
samples: int(),
|
|
@@ -61698,7 +61906,7 @@ var hostingServiceDataSchema = object({
|
|
|
61698
61906
|
consumers: array(string()),
|
|
61699
61907
|
dependencies: array(string())
|
|
61700
61908
|
});
|
|
61701
|
-
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");
|
|
61702
61910
|
var hostingServiceDeletionProtectionDataSchema = object({
|
|
61703
61911
|
environmentUuid: string(),
|
|
61704
61912
|
workloadUuid: string(),
|
|
@@ -61781,6 +61989,15 @@ var hostingSiteChecksDataSchema = object({
|
|
|
61781
61989
|
openIncidentStartedAt: string().nullable(),
|
|
61782
61990
|
openIncidentCause: string().nullable()
|
|
61783
61991
|
});
|
|
61992
|
+
var siteGeneratedFixSchema = object({
|
|
61993
|
+
format: string(),
|
|
61994
|
+
code: string()
|
|
61995
|
+
});
|
|
61996
|
+
var siteRemedySchema = object({
|
|
61997
|
+
kind: string(),
|
|
61998
|
+
element: string(),
|
|
61999
|
+
generated: union([siteGeneratedFixSchema, _null()])
|
|
62000
|
+
});
|
|
61784
62001
|
var hostingSiteFixEnumSchema = _enum([
|
|
61785
62002
|
"https-redirect",
|
|
61786
62003
|
"compression",
|
|
@@ -61799,6 +62016,7 @@ var hostingSiteFixDataSchema = object({
|
|
|
61799
62016
|
summary: string()
|
|
61800
62017
|
});
|
|
61801
62018
|
var hostingSiteFindingDataSchema = object({
|
|
62019
|
+
findingUuid: string(),
|
|
61802
62020
|
rule: string(),
|
|
61803
62021
|
severity: string(),
|
|
61804
62022
|
title: string(),
|
|
@@ -61807,6 +62025,8 @@ var hostingSiteFindingDataSchema = object({
|
|
|
61807
62025
|
fix: string(),
|
|
61808
62026
|
source: string(),
|
|
61809
62027
|
firstSeenAt: string(),
|
|
62028
|
+
remedy: siteRemedySchema,
|
|
62029
|
+
recheckable: boolean(),
|
|
61810
62030
|
hostingFix: union([hostingSiteFixDataSchema, _null()])
|
|
61811
62031
|
});
|
|
61812
62032
|
var hostingSiteIdentityAssignmentStatusEnumSchema = _enum([
|
|
@@ -61847,6 +62067,29 @@ var hostingSiteInsightStateEnumSchema = _enum([
|
|
|
61847
62067
|
"audited",
|
|
61848
62068
|
"unavailable"
|
|
61849
62069
|
]).describe("Where one site stands with Custd's audits, as the environment page shows it.\n| |\n|---|\n| `registering` <br/> Hosting has not yet claimed the domain in Custd; the next pass does. |\n| `awaiting-verification` <br/> Custd waits for the DNS record that proves the domain is the customer's. |\n| `withdrawing-attestation` <br/> Hosting's authority ended and Custd has yet to confirm withdrawal. |\n| `auditing` <br/> Verified; the first audit has not finished yet. |\n| `audited` <br/> At least one audit finished; its findings are shown. |\n| `unavailable` <br/> Custd could not be read just now; nothing is wrong with the site because of it. |");
|
|
62070
|
+
var siteNextActionTargetSchema = object({
|
|
62071
|
+
place: string(),
|
|
62072
|
+
findingUuid: string().nullable(),
|
|
62073
|
+
pageUrl: string().nullable()
|
|
62074
|
+
});
|
|
62075
|
+
var siteNextActionSchema = object({
|
|
62076
|
+
kind: string(),
|
|
62077
|
+
title: string(),
|
|
62078
|
+
why: string(),
|
|
62079
|
+
severity: string(),
|
|
62080
|
+
affectedCount: int(),
|
|
62081
|
+
target: siteNextActionTargetSchema,
|
|
62082
|
+
recheckable: boolean(),
|
|
62083
|
+
rule: string().nullable()
|
|
62084
|
+
});
|
|
62085
|
+
var hostingSiteNextActionsDataSchema = object({
|
|
62086
|
+
status: string(),
|
|
62087
|
+
headline: string(),
|
|
62088
|
+
checkedAt: string().nullable(),
|
|
62089
|
+
notChecked: array(string()),
|
|
62090
|
+
actionCount: int(),
|
|
62091
|
+
actions: array(siteNextActionSchema)
|
|
62092
|
+
});
|
|
61850
62093
|
var hostingSiteInsightDataSchema = object({
|
|
61851
62094
|
uuid: string(),
|
|
61852
62095
|
hostname: string(),
|
|
@@ -61858,6 +62101,7 @@ var hostingSiteInsightDataSchema = object({
|
|
|
61858
62101
|
lastAuditedAt: string().nullable(),
|
|
61859
62102
|
summary: union([hostingSiteAuditSummaryDataSchema, _null()]),
|
|
61860
62103
|
checks: union([hostingSiteChecksDataSchema, _null()]),
|
|
62104
|
+
nextActions: union([hostingSiteNextActionsDataSchema, _null()]),
|
|
61861
62105
|
findings: array(hostingSiteFindingDataSchema)
|
|
61862
62106
|
});
|
|
61863
62107
|
object({
|
|
@@ -61896,13 +62140,27 @@ object({
|
|
|
61896
62140
|
days: int(),
|
|
61897
62141
|
runs: array(siteLighthouseRunSchema)
|
|
61898
62142
|
});
|
|
62143
|
+
var sitePageRecheckStateSchema = _enum([
|
|
62144
|
+
"queued",
|
|
62145
|
+
"checked",
|
|
62146
|
+
"failed"
|
|
62147
|
+
]).describe("SitePageRecheckState is where a one-page recheck is: waiting for the scheduler, done, or failed.\n");
|
|
62148
|
+
object({
|
|
62149
|
+
recheckUuid: string(),
|
|
62150
|
+
url: string(),
|
|
62151
|
+
state: sitePageRecheckStateSchema.describe("SitePageRecheckState is where a one-page recheck is: waiting for the scheduler, done, or failed.\n"),
|
|
62152
|
+
requestedAt: string(),
|
|
62153
|
+
checkedAt: string().nullable(),
|
|
62154
|
+
openRules: array(string()),
|
|
62155
|
+
fixedRules: array(string())
|
|
62156
|
+
});
|
|
61899
62157
|
var siteUptimeStatusSchema = _enum([
|
|
61900
62158
|
"unknown",
|
|
61901
62159
|
"up",
|
|
61902
62160
|
"failing",
|
|
61903
62161
|
"down",
|
|
61904
62162
|
"paused"
|
|
61905
|
-
]).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/> |");
|
|
61906
62164
|
var siteUptimeWindowSchema = object({
|
|
61907
62165
|
checks: int(),
|
|
61908
62166
|
upChecks: int(),
|
|
@@ -61920,7 +62178,7 @@ var siteUptimeDaySchema = object({
|
|
|
61920
62178
|
upPercent: number().nullable()
|
|
61921
62179
|
});
|
|
61922
62180
|
var siteReportUptimeSchema = object({
|
|
61923
|
-
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/> |"),
|
|
61924
62182
|
windows: siteUptimeWindowsSchema,
|
|
61925
62183
|
days: array(siteUptimeDaySchema),
|
|
61926
62184
|
responseMs: int().nullable(),
|
|
@@ -62003,12 +62261,15 @@ object({
|
|
|
62003
62261
|
certificate: siteReportCertificateSchema,
|
|
62004
62262
|
speed: array(siteReportSpeedSchema),
|
|
62005
62263
|
search: siteReportSearchSchema,
|
|
62006
|
-
audit: siteReportAuditSchema
|
|
62264
|
+
audit: siteReportAuditSchema,
|
|
62265
|
+
template: string().nullable(),
|
|
62266
|
+
nextActions: array(siteNextActionSchema)
|
|
62007
62267
|
});
|
|
62008
62268
|
var siteReportShareSchema = object({
|
|
62009
62269
|
shareUuid: string(),
|
|
62010
62270
|
createdAt: string(),
|
|
62011
|
-
expiresAt: string()
|
|
62271
|
+
expiresAt: string(),
|
|
62272
|
+
reportUuid: string().nullable()
|
|
62012
62273
|
});
|
|
62013
62274
|
var hostingSiteReportLinkDataSchema = object({
|
|
62014
62275
|
share: siteReportShareSchema,
|
|
@@ -62020,11 +62281,11 @@ var siteSearchConnectionStatusSchema = _enum([
|
|
|
62020
62281
|
"active",
|
|
62021
62282
|
"failing",
|
|
62022
62283
|
"revoked"
|
|
62023
|
-
]).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. |");
|
|
62024
62285
|
var hostingSiteSearchConnectionDataSchema = object({
|
|
62025
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. |"),
|
|
62026
62287
|
property: string(),
|
|
62027
|
-
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. |"),
|
|
62028
62289
|
importedThrough: string().nullable(),
|
|
62029
62290
|
lastImportedAt: string().nullable()
|
|
62030
62291
|
});
|
|
@@ -62468,7 +62729,7 @@ var hostingTagDecisionEnumSchema = _enum([
|
|
|
62468
62729
|
"major_bump",
|
|
62469
62730
|
"prerelease",
|
|
62470
62731
|
"not_comparable"
|
|
62471
|
-
]).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. |");
|
|
62472
62733
|
var hostingTuningPreviewWorkloadDataSchema = object({
|
|
62473
62734
|
name: string(),
|
|
62474
62735
|
type: string(),
|
|
@@ -62499,10 +62760,10 @@ var hostingUpdateCandidateReasonEnumSchema = _enum([
|
|
|
62499
62760
|
"tags_are_not_versions",
|
|
62500
62761
|
"version_list_truncated",
|
|
62501
62762
|
"version_rule_refused"
|
|
62502
|
-
]).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. |");
|
|
62503
62764
|
var hostingUpdateCandidateDataSchema = object({
|
|
62504
62765
|
applicationUuid: string(),
|
|
62505
|
-
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. |"),
|
|
62506
62767
|
trackedRef: string().nullable().describe("The branch or tag this binding follows, as the decision read it."),
|
|
62507
62768
|
offeredRevision: string().nullable().describe("What upstream offers, or null when the decision refused before naming one."),
|
|
62508
62769
|
servingRevision: string().nullable().describe("What the environment serves now, in the same terms."),
|
|
@@ -62865,7 +63126,7 @@ object({
|
|
|
62865
63126
|
durationMonths: int().nullable().describe("Null is a continual price: it runs until an operator ends the window."),
|
|
62866
63127
|
packageKey: string().nullable().describe("The one package the code prices, or null for whichever package the client buys first."),
|
|
62867
63128
|
expiresAt: string().nullable(),
|
|
62868
|
-
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"),
|
|
62869
63130
|
basisPoints: int().nullable().describe("The share off the list price in ten-thousandths; null for a code that states a price instead."),
|
|
62870
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."),
|
|
62871
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.")
|
|
@@ -63774,7 +64035,7 @@ var stateManagerIntentRequestSchema = object({
|
|
|
63774
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.");
|
|
63775
64036
|
var storeBillingDiscountCodeRequestSchema = object({
|
|
63776
64037
|
company: string().max(64).nullish(),
|
|
63777
|
-
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"),
|
|
63778
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"),
|
|
63779
64040
|
packageKey: string().max(64).nullish(),
|
|
63780
64041
|
amountCents: int().min(0).max(1e8).optional(),
|
|
@@ -64156,7 +64417,7 @@ var storePlatformHostingEnvironmentRequestSchema = object({
|
|
|
64156
64417
|
name: string().max(100),
|
|
64157
64418
|
webServer: string().max(32).nullish(),
|
|
64158
64419
|
runtimeVersion: string().max(16).nullish(),
|
|
64159
|
-
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. |"),
|
|
64160
64421
|
replicas: int().min(1),
|
|
64161
64422
|
resources: object({
|
|
64162
64423
|
cpuRequestMillicores: int().min(1),
|
|
@@ -64245,7 +64506,7 @@ var updateBillingCustomerProfileRequestSchema = object({
|
|
|
64245
64506
|
postalCode: string().max(16).nullish(),
|
|
64246
64507
|
countryCode: string().min(2).max(2).optional(),
|
|
64247
64508
|
dueDays: int().nullish(),
|
|
64248
|
-
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. |")
|
|
64249
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.");
|
|
64250
64511
|
var updateBillingExportProfileRequestSchema = object({
|
|
64251
64512
|
name: string().max(64),
|
|
@@ -68893,16 +69154,22 @@ object({
|
|
|
68893
69154
|
environmentUuid: string(),
|
|
68894
69155
|
siteUuid: string()
|
|
68895
69156
|
});
|
|
69157
|
+
_enum(["executive", "full"]).optional();
|
|
68896
69158
|
union([
|
|
68897
69159
|
object({ message: string().describe("Error overview.") }),
|
|
68898
69160
|
object({ message: string().describe("Error overview.") }),
|
|
68899
|
-
messageDataSchema
|
|
69161
|
+
messageDataSchema,
|
|
69162
|
+
object({
|
|
69163
|
+
message: string().describe("Errors overview."),
|
|
69164
|
+
errors: record$3(string(), array(string())).describe("A detailed description of each field that failed validation.")
|
|
69165
|
+
})
|
|
68900
69166
|
]);
|
|
68901
69167
|
object({
|
|
68902
69168
|
company: string(),
|
|
68903
69169
|
environmentUuid: string(),
|
|
68904
69170
|
siteUuid: string()
|
|
68905
69171
|
});
|
|
69172
|
+
object({ template: _enum(["executive", "full"]).optional() });
|
|
68906
69173
|
int().min(1).max(90).optional();
|
|
68907
69174
|
union([
|
|
68908
69175
|
object({ message: string().describe("Error overview.") }),
|
|
@@ -68939,6 +69206,13 @@ object({
|
|
|
68939
69206
|
environmentUuid: string(),
|
|
68940
69207
|
siteUuid: string()
|
|
68941
69208
|
});
|
|
69209
|
+
union([object({ message: string().describe("Error overview.") }), object({ message: string().describe("Error overview.") })]);
|
|
69210
|
+
object({
|
|
69211
|
+
company: string(),
|
|
69212
|
+
environmentUuid: string(),
|
|
69213
|
+
siteUuid: string(),
|
|
69214
|
+
recheckUuid: string()
|
|
69215
|
+
});
|
|
68942
69216
|
union([
|
|
68943
69217
|
object({ message: string().describe("Error overview.") }),
|
|
68944
69218
|
object({ message: string().describe("Error overview.") }),
|
|
@@ -68993,6 +69267,21 @@ object({
|
|
|
68993
69267
|
environmentUuid: string(),
|
|
68994
69268
|
siteUuid: string()
|
|
68995
69269
|
});
|
|
69270
|
+
union([
|
|
69271
|
+
object({ message: string().describe("Error overview.") }),
|
|
69272
|
+
object({ message: string().describe("Error overview.") }),
|
|
69273
|
+
object({
|
|
69274
|
+
message: string().describe("Errors overview."),
|
|
69275
|
+
errors: record$3(string(), array(string())).describe("A detailed description of each field that failed validation.")
|
|
69276
|
+
}),
|
|
69277
|
+
messageDataSchema
|
|
69278
|
+
]);
|
|
69279
|
+
object({ url: url().max(2048) });
|
|
69280
|
+
object({
|
|
69281
|
+
company: string(),
|
|
69282
|
+
environmentUuid: string(),
|
|
69283
|
+
siteUuid: string()
|
|
69284
|
+
});
|
|
68996
69285
|
union([
|
|
68997
69286
|
object({ message: string().describe("Error overview.") }),
|
|
68998
69287
|
object({ message: string().describe("Error overview.") }),
|
|
@@ -70826,7 +71115,7 @@ object({
|
|
|
70826
71115
|
environment: string(),
|
|
70827
71116
|
migration: string()
|
|
70828
71117
|
});
|
|
70829
|
-
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");
|
|
70830
71119
|
union([
|
|
70831
71120
|
object({ message: string().describe("Error overview.") }),
|
|
70832
71121
|
messageDataSchema,
|
|
@@ -70835,7 +71124,7 @@ union([
|
|
|
70835
71124
|
errors: record$3(string(), array(string())).describe("A detailed description of each field that failed validation.")
|
|
70836
71125
|
})
|
|
70837
71126
|
]);
|
|
70838
|
-
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") });
|
|
70839
71128
|
union([
|
|
70840
71129
|
object({ message: string().describe("Error overview.") }),
|
|
70841
71130
|
messageDataSchema,
|
|
@@ -78506,6 +78795,44 @@ function bucketLine(review) {
|
|
|
78506
78795
|
const binds = bucket.binds ? ", then binds it to this environment before any application" : " and finds it already bound to this environment";
|
|
78507
78796
|
return [` It ${founds} bucket ${bucket.name} with ${String(bucket.packageGib)} GiB from the package${binds}, and buys nothing.`];
|
|
78508
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
|
+
}
|
|
78509
78836
|
// src/commands/environment-configuration-readiness.ts
|
|
78510
78837
|
var READY_WAIT_MS = 6e5;
|
|
78511
78838
|
var READY_POLL_MS = 3e3;
|
|
@@ -78526,7 +78853,7 @@ async function awaitReadiness(company, environmentUuid, generation, progress, de
|
|
|
78526
78853
|
const reported = status.message.trim();
|
|
78527
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);
|
|
78528
78855
|
if (status.status === "ready" && status.appliedGeneration >= generation) return environment;
|
|
78529
|
-
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)}`);
|
|
78530
78857
|
await new Promise((resolve) => setTimeout(resolve, READY_POLL_MS));
|
|
78531
78858
|
}
|
|
78532
78859
|
}
|
|
@@ -80207,6 +80534,21 @@ var SITE_INSIGHTS_FLAG_SPECS = [
|
|
|
80207
80534
|
takesValue: true,
|
|
80208
80535
|
description: "The number of days of Lighthouse lab runs, from 1 to 30."
|
|
80209
80536
|
},
|
|
80537
|
+
{
|
|
80538
|
+
name: "--template",
|
|
80539
|
+
takesValue: true,
|
|
80540
|
+
description: "The report layout: executive for the short summary, or full. Defaults to full."
|
|
80541
|
+
},
|
|
80542
|
+
{
|
|
80543
|
+
name: "--url",
|
|
80544
|
+
takesValue: true,
|
|
80545
|
+
description: "The page `environment site-insights-page-recheck` checks again, on the site's own address."
|
|
80546
|
+
},
|
|
80547
|
+
{
|
|
80548
|
+
name: "--recheck",
|
|
80549
|
+
takesValue: true,
|
|
80550
|
+
description: "The page check UUID `environment site-insights-page-recheck` prints."
|
|
80551
|
+
},
|
|
80210
80552
|
{
|
|
80211
80553
|
name: "--expires-in-days",
|
|
80212
80554
|
takesValue: true,
|
|
@@ -80300,19 +80642,24 @@ var SITE_REPORT_COMMANDS = [
|
|
|
80300
80642
|
"site-insights-incidents",
|
|
80301
80643
|
"site-insights-report-shares",
|
|
80302
80644
|
"site-insights-report-share-create",
|
|
80303
|
-
"site-insights-report-share-revoke"
|
|
80645
|
+
"site-insights-report-share-revoke",
|
|
80646
|
+
"site-insights-page-recheck",
|
|
80647
|
+
"site-insights-page-recheck-status"
|
|
80304
80648
|
];
|
|
80649
|
+
var REPORT_TEMPLATES = ["executive", "full"];
|
|
80305
80650
|
var USAGE$30 = [
|
|
80306
80651
|
"Usage: hostingctl environment <command> <environment-uuid> --site <site-uuid> --company <slug>",
|
|
80307
|
-
" site-insights-report Read the authenticated report.",
|
|
80652
|
+
" site-insights-report Read the authenticated report [--template <executive|full>].",
|
|
80308
80653
|
" site-insights-uptime-history Read hourly response times [--response-days <1-90>].",
|
|
80309
80654
|
" site-insights-lighthouse-history Read Lighthouse lab runs [--days <1-30>].",
|
|
80310
80655
|
" site-insights-incidents Read up to twenty recent outages.",
|
|
80311
80656
|
" site-insights-report-shares List share identifiers and expiry.",
|
|
80312
80657
|
" site-insights-report-share-create Create a one-time link [--expires-in-days <1-90>].",
|
|
80313
80658
|
" site-insights-report-share-revoke Revoke the link named by --share <uuid>.",
|
|
80659
|
+
" site-insights-page-recheck Check the page named by --url <url> again now.",
|
|
80660
|
+
" site-insights-page-recheck-status Read the check named by --recheck <uuid>.",
|
|
80314
80661
|
"",
|
|
80315
|
-
"Creation and
|
|
80662
|
+
"Creation, revocation and a page check need --confirm. Use --dry-run to preview any write."
|
|
80316
80663
|
].join("\n");
|
|
80317
80664
|
function isSiteReportCommand(action) {
|
|
80318
80665
|
return SITE_REPORT_COMMANDS.some((command) => command === action);
|
|
@@ -80330,7 +80677,10 @@ async function environmentSiteReport(context, action, args) {
|
|
|
80330
80677
|
switch (action) {
|
|
80331
80678
|
case "site-insights-report": return {
|
|
80332
80679
|
kind: action,
|
|
80333
|
-
report: (await hostingSiteInsightsReport({
|
|
80680
|
+
report: (await hostingSiteInsightsReport({
|
|
80681
|
+
path,
|
|
80682
|
+
query: context.flags.has("--template") ? { template: templateFlag(context) } : void 0
|
|
80683
|
+
})).data
|
|
80334
80684
|
};
|
|
80335
80685
|
case "site-insights-uptime-history": return {
|
|
80336
80686
|
kind: action,
|
|
@@ -80362,8 +80712,35 @@ async function environmentSiteReport(context, action, args) {
|
|
|
80362
80712
|
kind: action,
|
|
80363
80713
|
outcome: await revokeShare(context, path)
|
|
80364
80714
|
};
|
|
80715
|
+
case "site-insights-page-recheck": return {
|
|
80716
|
+
kind: action,
|
|
80717
|
+
outcome: await requestPageRecheck(context, path)
|
|
80718
|
+
};
|
|
80719
|
+
case "site-insights-page-recheck-status": {
|
|
80720
|
+
const recheckUuid = requiredFlag$4(context, "--recheck", USAGE$30);
|
|
80721
|
+
return {
|
|
80722
|
+
kind: action,
|
|
80723
|
+
recheck: (await hostingSiteInsightsPageRecheck({ path: {
|
|
80724
|
+
...path,
|
|
80725
|
+
recheckUuid
|
|
80726
|
+
} })).data
|
|
80727
|
+
};
|
|
80728
|
+
}
|
|
80365
80729
|
}
|
|
80366
80730
|
}
|
|
80731
|
+
function templateFlag(context) {
|
|
80732
|
+
const value = requiredFlag$4(context, "--template", USAGE$30);
|
|
80733
|
+
const template = REPORT_TEMPLATES.find((candidate) => candidate === value);
|
|
80734
|
+
if (template === void 0) throw new UsageError("--template must be executive or full.");
|
|
80735
|
+
return template;
|
|
80736
|
+
}
|
|
80737
|
+
function requestPageRecheck(context, path) {
|
|
80738
|
+
const url = requiredFlag$4(context, "--url", USAGE$30);
|
|
80739
|
+
return confirmableWrite(context, `check ${url} again for site ${path.siteUuid} on environment ${path.environmentUuid}`, async () => (await hostingSiteInsightsRequestPageRecheck({
|
|
80740
|
+
path,
|
|
80741
|
+
body: { url }
|
|
80742
|
+
})).data);
|
|
80743
|
+
}
|
|
80367
80744
|
function daysFlag(context, flag, maximum) {
|
|
80368
80745
|
if (!context.flags.has(flag)) return void 0;
|
|
80369
80746
|
const value = requiredFlag$4(context, flag, USAGE$30);
|
|
@@ -80683,7 +81060,10 @@ var ENVIRONMENT_USAGE = [
|
|
|
80683
81060
|
" site-insights Custd's audits of each application's primary domain: state, TXT record, uptime, TLS and",
|
|
80684
81061
|
" findings. -verify, -audit and -fix act on one --site; -fix takes --fix <name>.",
|
|
80685
81062
|
" site-insights-report, site-insights-uptime-history, site-insights-lighthouse-history and",
|
|
80686
|
-
" site-insights-incidents read one --site. Use --response-days for uptime and --days for Lighthouse
|
|
81063
|
+
" site-insights-incidents read one --site. Use --response-days for uptime and --days for Lighthouse,",
|
|
81064
|
+
" and --template <executive|full> for the report.",
|
|
81065
|
+
" site-insights-page-recheck --url <url> checks one page again; read the result with",
|
|
81066
|
+
" site-insights-page-recheck-status --recheck <uuid>.",
|
|
80687
81067
|
" site-insights-report-shares lists one site's shares. Use site-insights-report-share-create",
|
|
80688
81068
|
" [--expires-in-days <1-90>] to get a link, or site-insights-report-share-revoke --share <uuid>.",
|
|
80689
81069
|
" site-insights-search reads one site's search providers. Use site-insights-search-connect",
|
|
@@ -82441,8 +82821,17 @@ function domainLine(one) {
|
|
|
82441
82821
|
lines.push(` ownership check: ${one.ownershipCheckDetail}`);
|
|
82442
82822
|
for (const record of one.records.filter((each) => each.purpose === "ownership")) lines.push(` publish ${record.type} ${record.name} ${record.value}`);
|
|
82443
82823
|
}
|
|
82824
|
+
lines.push(` ${publicationLine(one.publication)}`);
|
|
82444
82825
|
return lines.join("\n");
|
|
82445
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
|
+
}
|
|
82446
82835
|
/** The `environment domain*`/`redirect*` renderer. */
|
|
82447
82836
|
function environmentDomainText(report) {
|
|
82448
82837
|
if (report.kind === "domain-write") {
|
|
@@ -82473,6 +82862,12 @@ function checksLines(checks) {
|
|
|
82473
82862
|
/** One site: where it stands, what proves it, and what the last audit found. */
|
|
82474
82863
|
function siteLines(site) {
|
|
82475
82864
|
const lines = [` ${site.hostname} ${site.state} site ${site.uuid}`, ` application ${site.applicationName ?? "none"}`];
|
|
82865
|
+
const next = site.nextActions;
|
|
82866
|
+
if (next !== null) {
|
|
82867
|
+
lines.push(` next ${next.headline}`);
|
|
82868
|
+
const [first] = next.actions;
|
|
82869
|
+
if (first !== void 0) lines.push(` first ${first.title}: ${first.why}`);
|
|
82870
|
+
}
|
|
82476
82871
|
const record = site.verificationRecord;
|
|
82477
82872
|
if (record !== null) lines.push(` record ${record.type} ${record.name} ${record.value}`);
|
|
82478
82873
|
if (site.lastFailure !== null) lines.push(` failure ${site.lastFailure}`);
|
|
@@ -82513,8 +82908,10 @@ function reportText(report) {
|
|
|
82513
82908
|
["30 days", uptime.windows.last30d]
|
|
82514
82909
|
];
|
|
82515
82910
|
return [
|
|
82516
|
-
`${report.host} · uptime ${uptime.status} · generated ${report.generatedAt}`,
|
|
82911
|
+
`${report.host} · uptime ${uptime.status} · generated ${report.generatedAt} · ${report.template ?? "full"} report`,
|
|
82517
82912
|
...uptime.downSince === null ? [] : [`Down since ${uptime.downSince}`],
|
|
82913
|
+
...report.nextActions.length === 0 ? [] : ["What to do next"],
|
|
82914
|
+
...report.nextActions.map((action, index) => ` ${index + 1}. ${action.title}: ${action.why}`),
|
|
82518
82915
|
"Uptime",
|
|
82519
82916
|
...windows.map(([label, window]) => ` ${label} ${window.upPercent === null ? "unknown" : `${window.upPercent}%`} (${window.checks} checks)`),
|
|
82520
82917
|
`TLS ${certificate.problem ? "needs attention" : certificate.issuer ?? "issuer unknown"} · expires ${certificate.validTo ?? "unknown"}`,
|
|
@@ -82538,8 +82935,20 @@ function environmentSiteReportText(answer) {
|
|
|
82538
82935
|
case "site-insights-report-shares": return answer.shares.length === 0 ? "No report shares." : answer.shares.map((share) => ` ${share.shareUuid} · created ${share.createdAt} · expires ${share.expiresAt}`).join("\n");
|
|
82539
82936
|
case "site-insights-report-share-create": return renderWriteOutcome(answer.outcome, (result) => `Share ${result.share.shareUuid} expires ${result.share.expiresAt}. Copy this link now.\n${result.url}`);
|
|
82540
82937
|
case "site-insights-report-share-revoke": return renderWriteOutcome(answer.outcome, () => "Report share revoked.");
|
|
82938
|
+
case "site-insights-page-recheck": return renderWriteOutcome(answer.outcome, recheckText);
|
|
82939
|
+
case "site-insights-page-recheck-status": return recheckText(answer.recheck);
|
|
82541
82940
|
}
|
|
82542
82941
|
}
|
|
82942
|
+
/** A page check's state; a rule is fixed only when a finished check lists it as fixed. */
|
|
82943
|
+
function recheckText(recheck) {
|
|
82944
|
+
if (recheck.state === "queued") return `Check ${recheck.recheckUuid} of ${recheck.url} is queued. Read it with site-insights-page-recheck-status --recheck ${recheck.recheckUuid}.`;
|
|
82945
|
+
if (recheck.state === "failed") return `The check of ${recheck.url} failed. Try again later.`;
|
|
82946
|
+
return [
|
|
82947
|
+
`Checked ${recheck.url} at ${recheck.checkedAt ?? "unknown"}`,
|
|
82948
|
+
` fixed ${recheck.fixedRules.join(", ") || "none"}`,
|
|
82949
|
+
` open ${recheck.openRules.join(", ") || "none"}`
|
|
82950
|
+
].join("\n");
|
|
82951
|
+
}
|
|
82543
82952
|
function milliseconds(value) {
|
|
82544
82953
|
return value === null ? "unknown" : `${value} ms`;
|
|
82545
82954
|
}
|
|
@@ -82704,6 +83113,7 @@ function environmentText(report) {
|
|
|
82704
83113
|
` namespace ${report.namespace}`,
|
|
82705
83114
|
` cluster ${report.cluster.name}`,
|
|
82706
83115
|
` status ${report.status.status} generation ${String(report.status.generation)} applied ${String(report.status.appliedGeneration)}`,
|
|
83116
|
+
...statusStoryLines(report.status),
|
|
82707
83117
|
` observed ${report.status.observedAt ?? "never"}`,
|
|
82708
83118
|
` reconciled ${lastReconcile(report.lastReconcile)}`,
|
|
82709
83119
|
...allocationSummaryLines(report.allocationSummary)
|
|
@@ -82729,17 +83139,7 @@ function allocationSummaryLines(summary) {
|
|
|
82729
83139
|
function writeText$2(report) {
|
|
82730
83140
|
const receipt = renderWriteOutcome(report, outcomeOf$1);
|
|
82731
83141
|
if (!("readiness" in report) || report.readiness === void 0) return receipt;
|
|
82732
|
-
return `${receipt}\n${environmentText(report.readiness)}${statusMessage(report.readiness)}`;
|
|
82733
|
-
}
|
|
82734
|
-
/**
|
|
82735
|
-
* The platform's own message for the reading, when it wrote one.
|
|
82736
|
-
*
|
|
82737
|
-
* The status word says whether the generation was applied; the message is the only thing that says why not, so it is
|
|
82738
|
-
* printed rather than held back to the JSON answer.
|
|
82739
|
-
*/
|
|
82740
|
-
function statusMessage(environment) {
|
|
82741
|
-
const message = environment.status.message.trim();
|
|
82742
|
-
return message === "" ? "" : `\n message ${message}`;
|
|
83142
|
+
return `${receipt}\n${environmentText(report.readiness)}${statusMessage(report.readiness.status)}`;
|
|
82743
83143
|
}
|
|
82744
83144
|
/**
|
|
82745
83145
|
* The reference directory: one line per producer — its kind, its key, then what may be read from it.
|
|
@@ -83333,6 +83733,29 @@ var environments = {
|
|
|
83333
83733
|
return report.items.map((one) => ` ${one.uuid} ${one.slug.padEnd(width)} ${one.name} ${one.cluster.name}`).join("\n");
|
|
83334
83734
|
}
|
|
83335
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
|
+
}
|
|
83336
83759
|
// src/commands/files-import-schedule.ts
|
|
83337
83760
|
/** `--mirror` and its `--max-delete`, as the request fields; a copy takes neither. */
|
|
83338
83761
|
function mirrorFields(context) {
|
|
@@ -83388,9 +83811,9 @@ function scheduleLines(schedule) {
|
|
|
83388
83811
|
function runLines(one) {
|
|
83389
83812
|
if (one.runs.length === 0) return [];
|
|
83390
83813
|
return [" latest runs:", ...one.runs.map((run) => {
|
|
83391
|
-
const failure = run.failureReason === null ? "" :
|
|
83814
|
+
const failure = run.failureReason === null ? "" : `\n ${providerFailureSentence(run.failureReason)}`;
|
|
83392
83815
|
const kept = run.recoveryFolder === null ? "" : `\n ${recoveryFolderLine(run.recoveryFolder)}`;
|
|
83393
|
-
return ` ${run.uuid} ${run.state}
|
|
83816
|
+
return ` ${run.uuid} ${run.state} started ${run.createdAt}${failure}${kept}`;
|
|
83394
83817
|
})];
|
|
83395
83818
|
}
|
|
83396
83819
|
/** Where a mirror kept the files it replaced or deleted, and until when, in plain words. */
|
|
@@ -83607,7 +84030,7 @@ function progressLine(one) {
|
|
|
83607
84030
|
}
|
|
83608
84031
|
/** One import as a person reads it. */
|
|
83609
84032
|
function describeImport(one) {
|
|
83610
|
-
const failure = one.failureReason === null ? "" : `\n failed: ${one.failureReason}`;
|
|
84033
|
+
const failure = one.failureReason === null ? "" : `\n failed: ${providerFailureSentence(one.failureReason)}`;
|
|
83611
84034
|
const next = one.nextAttemptAt === null ? "" : `\n next attempt ${one.nextAttemptAt}`;
|
|
83612
84035
|
const cap = one.maxDelete === null ? "" : `\n deletes at most ${String(one.maxDelete)} files a run`;
|
|
83613
84036
|
return [
|
|
@@ -93847,7 +94270,7 @@ function writeUpdateState(state, env = process.env) {
|
|
|
93847
94270
|
} catch {}
|
|
93848
94271
|
}
|
|
93849
94272
|
// src/version.ts
|
|
93850
|
-
var VERSION = "1.0.
|
|
94273
|
+
var VERSION = "1.0.870";
|
|
93851
94274
|
// src/commands/update.ts
|
|
93852
94275
|
/**
|
|
93853
94276
|
* `update` — bring this copy of the CLI up to the published version.
|
|
@@ -93921,7 +94344,7 @@ var update = {
|
|
|
93921
94344
|
}, process.env);
|
|
93922
94345
|
return {
|
|
93923
94346
|
...known,
|
|
93924
|
-
current: after ?? "1.0.
|
|
94347
|
+
current: after ?? "1.0.870",
|
|
93925
94348
|
latest: after ?? latest,
|
|
93926
94349
|
upToDate: after !== null && (latest === null || !isNewerVersion(latest, after)),
|
|
93927
94350
|
action: "run",
|
|
@@ -94207,7 +94630,7 @@ async function printUpdateNotice(options) {
|
|
|
94207
94630
|
}, env, { waitMs: NOTICE_LOCK_WAIT_MS });
|
|
94208
94631
|
} catch {}
|
|
94209
94632
|
if (latest === null) return;
|
|
94210
|
-
if (!isNewerVersion(latest, "1.0.
|
|
94633
|
+
if (!isNewerVersion(latest, "1.0.870")) return;
|
|
94211
94634
|
process.stderr.write(`A newer hostingctl is published: ${latest} (this copy is ${VERSION}). Run \`hostingctl update\` to update.\n`);
|
|
94212
94635
|
}
|
|
94213
94636
|
/** Whether an environment variable is set to something, which is how CI and the opt-out are read. */
|