@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 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
- ...log.failureStage === null ? [] : [` failed at ${log.failureStage}: ${log.failureReason ?? "no reason recorded"}`],
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 \`hostingctl application build-log ${path.environmentUuid} ${path.workloadUuid} ${failed.uuid} --company <slug>\`; its upload and build are kept.`, (releaseUuid) => record({
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}${reason.length === 0 ? "" : ` at ${reason.join(": ")}`}.`,
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 \`hostingctl application build-log ${path.environmentUuid} ${path.workloadUuid} ${failed.uuid}\`.`);
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
- return await dispatched$2(context, action, {
47895
+ const path = {
47738
47896
  company,
47739
47897
  environmentUuid,
47740
47898
  workloadUuid
47741
- }, extra);
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. Keeping all three in one effective-dated price table means there is one place a price lives, not three.\n");
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/> |\n| `unallocated` <br/> |\n| `reversed` <br/> The money came back: a refund or a dispute an operator established and attributed. |");
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/> |\n| `unallocated` <br/> |\n| `reversed` <br/> The money came back: a refund or a dispute an operator established and attributed. |"),
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. Slugs are stable because the database's shape constraint is built from the seeded ids; renaming one is a migration, not an edit.\n");
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. Slugs are stable because the database's shape constraint is built from the seeded ids; renaming one is a migration, not an edit.\n"),
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. 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. |");
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. 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. |"),
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 * accepted it for the billing contact\". A failed or missing contact never un-issues the document.\n");
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. 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");
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. 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. |"),
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. 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"),
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 * accepted it for the billing contact\". A failed or missing contact never un-issues the document.\n"),
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 * accepted it for the billing contact\". A failed or missing contact never un-issues the document.\n"),
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. Keeping all three in one effective-dated price table means there is one place a price lives, not three.\n"),
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. Keeping all three in one effective-dated price table means there is one place a price lives, not three.\n"),
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. 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. |");
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/> |\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/> |");
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. `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");
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. `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"),
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. 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");
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. 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. |");
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. 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. |"),
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 * 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. |"),
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`. 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. |");
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`. 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. |"),
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: object({
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. `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")
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 * 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\". |"),
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. 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");
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. 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");
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. 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"),
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. 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"),
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 * 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");
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 * 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"),
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. `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"),
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. `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");
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. `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"),
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 * 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. |");
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 * 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. |"),
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. `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. |");
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. `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. |"),
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. {@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()]),
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. 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"),
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 * 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. |"),
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/> |\n| `failed` <br/> |\n| `not_reached` <br/> An earlier step failed, so this one was never tried. |");
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/> |\n| `failed` <br/> |\n| `not_reached` <br/> An earlier step failed, so this one was never tried. |"),
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. - `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");
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, * 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");
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/> |\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/> |");
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/> |\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/> |"),
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/> |\n| `failing` <br/> The latest import failed; lastFailure says why. |\n| `revoked` <br/> The provider no longer lets Custd read the property. |");
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/> |\n| `failing` <br/> The latest import failed; lastFailure says why. |\n| `revoked` <br/> The provider no longer lets Custd read the property. |"),
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. 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. |");
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. 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. |");
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. 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. |"),
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. 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"),
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. 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"),
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. 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. |"),
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. 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. |")
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. - `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");
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. - `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") });
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)})${reported === "" ? "" : `: ${reported}`}`);
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 revocation need --confirm. Use --dry-run to preview either write."
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({ path })).data
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 ? "" : ` (${run.failureReason})`;
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}${failure} started ${run.createdAt}${kept}`;
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.865";
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.865",
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.865")) return;
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. */