@scalar/cli 2.1.0 → 2.5.1

package/chunks/{chunk-HQKBZOYU.js → chunk-PT5TI77I.js}

@@ -1,13 +1,13 @@
 import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
 import {
   BaseCollections
-} from "./chunk-2BSG2QHO.js";
+} from "./chunk-F467BYYR.js";
 import {
   getDatabaseClient
-} from "./chunk-SHSHFGA7.js";
+} from "./chunk-Z2KMGFE6.js";
 import {
   publishRecordSchema
-} from "./chunk-ISGLWBXZ.js";
+} from "./chunk-OQKDBLOZ.js";
 
 // src/domains/project/deployments/get-deployments.ts
 function orderDeployments(records) {

package/chunks/chunk-Q7DOQHZN.js

@@ -0,0 +1,404 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  methodSchema
+} from "./chunk-GSGZHE26.js";
+import {
+  brandedUid,
+  docVersionSchema,
+  entitySchema,
+  external_exports,
+  mintUid,
+  namespaceSchema,
+  nanoidSchema,
+  randomManagedDocSlug,
+  scalarSet,
+  slugSchema,
+  timestampSchema
+} from "./chunk-IKT5F47M.js";
+
+// ../../packages/entities/dist/registry/instance.js
+var contentShaSchema = external_exports.string().regex(/^[a-f0-9]{64}$/, "Content sha must be a sha-256 hex digest");
+var docInstanceSourceSchema = external_exports.enum(["manual", "cli", "api", "git-sync", "url-sync", "migration"]).meta({ id: "doc-instance-source" });
+var docInstanceOriginSchema = external_exports.discriminatedUnion("type", [
+  external_exports.object({ type: external_exports.literal("platform") }),
+  external_exports.object({
+    type: external_exports.literal("git"),
+    /**
+     * Commit that carried this content. Null when the content landed but the
+     * commit did not — the mirror is best-effort and can be switched off.
+     */
+    commitSha: external_exports.string().nullable().default(null),
+    /** Branch this content was committed on. Null for direct-to-published writes. */
+    branch: external_exports.string().nullable().default(null),
+    /**
+     * A platform edit to a git-sourced document that went out as a pull
+     * request. Open while `resolution` is null; the webhook stamps `merged`
+     * or `closed` when the pull request settles, so "does this document have
+     * an open proposal" is answerable from the log alone. The row itself is
+     * append-only history — a merged proposal's content re-enters the log as
+     * a fresh instance via the merge push.
+     */
+    draft: external_exports.object({
+      prNumber: external_exports.number(),
+      branch: external_exports.string(),
+      /** How the pull request settled; null while it is still open. */
+      resolution: external_exports.enum(["merged", "closed"]).nullable().default(null)
+    }).nullable().default(null)
+  }),
+  external_exports.object({
+    type: external_exports.literal("url"),
+    /** Upstream this content was fetched from. */
+    url: external_exports.url()
+  })
+]).meta({ id: "doc-instance-origin" });
+var docInstanceSchema = entitySchema.extend({
+  /** Own uid, branded so it cannot be confused with another entity's uid */
+  uid: brandedUid().default(mintUid).meta({ default: "nanoid()" }),
+  /** Version label the content declared (info.version) or the caller supplied */
+  version: docVersionSchema,
+  /**
+   * SHA-256 hex digest of the serialized JSON — the single content identity.
+   * Blob keys for BOTH formats derive from it: `blobs/<jsonSha>.json` and
+   * `blobs/<jsonSha>.yaml`.
+   */
+  jsonSha: contentShaSchema,
+  /**
+   * SHA-256 hex digest of the serialized YAML twin. Integrity metadata for
+   * verifying served YAML bytes — never a storage key.
+   */
+  yamlSha: contentShaSchema,
+  /** User uid or email that produced this content. Null for system syncs. */
+  uploadedBy: external_exports.string().nullable().default(null),
+  /** The channel that triggered the write */
+  source: docInstanceSourceSchema,
+  /** Where the bytes came from; platform-native unless a git or url source supplied them */
+  origin: docInstanceOriginSchema.default({ type: "platform" }),
+  /** Free-form commit-style message supplied by the writer */
+  message: external_exports.string().default(""),
+  /**
+   * Lineage pointers recorded from day one so instances form a DAG. Branch
+   * and merge flows build on this; backfilling parents later would be far
+   * more expensive than stamping them now.
+   */
+  parentInstanceUid: brandedUid().nullable().default(null),
+  /** Second parent for merge commits */
+  mergeParentUid: brandedUid().nullable().default(null),
+  /**
+   * The instance this one reverts to. Set only by rollback, which appends a
+   * new instance carrying the target's content hashes rather than mutating
+   * any pointer — so history renders "reverted to X" without diffing hashes,
+   * and the chain stays append-only.
+   */
+  revertOf: brandedUid().nullable().default(null),
+  /**
+   * Denormalized serving eligibility, stamped false only on draft instances.
+   * Exists solely for the chain's unique-parent index: Mongo partial indexes
+   * cannot express "origin.draft is null or missing", so eligibility needs a
+   * stored equality field. {@link isServingEligibleInstance} (origin-derived)
+   * stays the read-side authority; this field is never read by resolvers.
+   */
+  servable: external_exports.boolean().default(true)
+}).meta({ id: "doc-instance" });
+
+// ../../packages/entities/dist/registry/schema.js
+var RegistryAsset;
+(function(RegistryAsset2) {
+  RegistryAsset2["Apis"] = "apis";
+  RegistryAsset2["Rules"] = "rules";
+  RegistryAsset2["Schemas"] = "schemas";
+  RegistryAsset2["Sdks"] = "sdks";
+  RegistryAsset2["Workspaces"] = "workspaces";
+})(RegistryAsset || (RegistryAsset = {}));
+var RegistryResourceTypes = [
+  RegistryAsset.Apis,
+  RegistryAsset.Schemas,
+  RegistryAsset.Rules,
+  RegistryAsset.Sdks,
+  RegistryAsset.Workspaces
+];
+var registryAssetSchema = external_exports.enum(RegistryAsset).meta({ id: "registry-asset" });
+var registryGitExternalSchema = external_exports.discriminatedUnion("provider", [
+  external_exports.object({
+    provider: external_exports.literal("github"),
+    linkedBy: external_exports.string(),
+    installationId: external_exports.number().int(),
+    id: external_exports.number().int(),
+    name: external_exports.string().min(2),
+    branch: external_exports.string().default("main"),
+    /** Where the canonical file lives inside the linked repo. */
+    path: external_exports.string().default(""),
+    webhookId: external_exports.string().default("")
+  }),
+  external_exports.object({
+    provider: external_exports.literal("bitbucket"),
+    linkedBy: external_exports.string(),
+    workspaceUuid: external_exports.string(),
+    workspaceSlug: external_exports.string(),
+    repoUuid: external_exports.string(),
+    repoSlug: external_exports.string(),
+    name: external_exports.string().min(2),
+    branch: external_exports.string().default("main"),
+    webhookUuid: external_exports.string().default("")
+  })
+]).meta({ id: "registry-git-external" });
+var registryGitBindingSchema = external_exports.object({
+  forgejo: external_exports.object({
+    owner: external_exports.string(),
+    repo: external_exports.string(),
+    branch: external_exports.string().default("main")
+  }),
+  /** Publish when a commit lands on the tracked branch. */
+  publishOnPush: external_exports.boolean().default(true),
+  /** Publish when a pull request is merged. */
+  publishOnMerge: external_exports.boolean().default(false),
+  trackedBranch: external_exports.string().default("main"),
+  /** Forgejo webhook id, so it can be updated or removed. */
+  webhookId: external_exports.number().nullable().default(null),
+  external: registryGitExternalSchema.nullable().default(null),
+  /** The commit currently served as the published state. */
+  currentPublishedSha: external_exports.string().nullable().default(null),
+  lastPublishedAt: timestampSchema.nullable().default(null)
+}).meta({ id: "registry-git-binding" });
+var docSourceSchema = external_exports.discriminatedUnion("type", [
+  external_exports.object({ type: external_exports.literal("platform") }),
+  external_exports.object({
+    type: external_exports.literal("git"),
+    /** The team's linked repository this document sources from. */
+    repositoryUid: nanoidSchema.brand(),
+    /** Where the canonical file lives inside the repository. */
+    path: external_exports.string().min(1),
+    /**
+     * The branch publishes track and pull requests target. Null follows the
+     * repository's default branch.
+     */
+    branch: external_exports.string().nullable().default(null),
+    /** Publish when a commit lands on the tracked branch. */
+    publishOnPush: external_exports.boolean().default(true),
+    /** Publish when a pull request merges into the tracked branch. */
+    publishOnMerge: external_exports.boolean().default(false),
+    /**
+     * The commit currently served as the published state. Advanced by
+     * compare-and-swap so redelivered webhooks and racing publishes cannot
+     * interleave the publish log and the pointer.
+     */
+    currentPublishedSha: external_exports.string().nullable().default(null),
+    lastPublishedAt: timestampSchema.nullable().default(null)
+  }),
+  external_exports.object({
+    type: external_exports.literal("url"),
+    url: external_exports.url(),
+    linkedBy: external_exports.string(),
+    /** ETag from the last fetch so refreshes can use If-None-Match */
+    etag: external_exports.string().nullable().default(null),
+    lastFetchedAt: timestampSchema.nullable().default(null)
+  })
+]).meta({ id: "doc-source" });
+var baseRegistrySchema = entitySchema.extend({
+  /** Team namespace - not linked by UID */
+  namespace: namespaceSchema,
+  /** UI label for registry item */
+  title: external_exports.string().max(100).default(""),
+  /** Unique configuration identifier */
+  slug: slugSchema.default(randomManagedDocSlug).meta({ default: "randomManagedDocSlug()" }),
+  /** Extended description for registry item */
+  description: external_exports.string().default(""),
+  /** Public accessibility */
+  isPrivate: external_exports.boolean().default(false),
+  /**
+   * Surfaced ahead of the rest of the list on the namespace's registry page.
+   * A record only ever belongs to one namespace, so this needs no target.
+   */
+  pinned: external_exports.boolean().default(false),
+  /** Grouping/identifier tags */
+  tags: scalarSet(external_exports.set(external_exports.string()).max(100)).default([]),
+  /** Access groups for private access permissions */
+  accessGroups: scalarSet(external_exports.set(nanoidSchema).max(50)).default([]),
+  /** The uid of the login portal customization object for private documents */
+  loginPortalUid: external_exports.string().optional(),
+  /** Whether the content has been scanned and confirmed to not to contain malicious content */
+  verifiedContent: external_exports.boolean().optional(),
+  /**
+   * Where this document's content is authored. Records written before this
+   * field existed omit it and read back as platform-native.
+   *
+   * Kept a plain `.default()` rather than a `.nullish().transform()` that
+   * would also absorb a stored `null`: the API framework drops piped fields
+   * from generated response types, so a transform here erases `source` from
+   * every registry response. Nothing writes `null`, so write it as `undefined`
+   * (omit the field) rather than reintroducing the pipe.
+   */
+  source: docSourceSchema.default({ type: "platform" }),
+  /**
+   * @deprecated Forgejo registry backing is being retired in favor of
+   * content-addressed GCS blobs + the instance log. Use `source` for the
+   * external-repo link. Dropped once the backfill is verified.
+   */
+  git: registryGitBindingSchema.nullable().optional()
+}).meta({ id: "base-registry" });
+
+// ../../packages/entities/dist/registry/migration.js
+var registryGitMigrationResourceSchema = external_exports.object({
+  asset: registryAssetSchema,
+  namespace: namespaceSchema,
+  slug: slugSchema,
+  resourceUid: nanoidSchema,
+  status: external_exports.enum([
+    "migrated",
+    "already-migrated",
+    "partial",
+    "would-migrate",
+    "error"
+  ]),
+  versionsImported: external_exports.number().default(0),
+  versionsSkipped: external_exports.number().default(0),
+  error: external_exports.string().default("")
+});
+var registryGitMigrationStatusSchema = external_exports.enum([
+  "running",
+  "complete",
+  "partial",
+  "failed"
+]);
+var registryGitMigrationSchema = entitySchema.extend({
+  teamUid: brandedUid(),
+  dryRun: external_exports.boolean().default(false),
+  status: registryGitMigrationStatusSchema,
+  /**
+   * While `running`, the unix time after which the lease is considered
+   * abandoned and another run may take over. Renewed as the run progresses, so
+   * it only lapses when the run really stopped (a crash, a killed pod) rather
+   * than because the work took a while. Zero once the run has finished.
+   */
+  lockedUntil: external_exports.number().default(0),
+  resources: registryGitMigrationResourceSchema.array().default([])
+}).meta({ id: "registry-git-migration" });
+
+// ../../packages/entities/dist/registry/publish.js
+var registryPublishSourceSchema = external_exports.enum(["manual", "git-hook", "external-push", "migration"]).meta({ id: "registry-publish-source" });
+var registryPublishAuthorSchema = external_exports.object({
+  name: external_exports.string(),
+  email: external_exports.string()
+});
+var registryPublishRecordSchema = entitySchema.extend({
+  resourceUid: nanoidSchema,
+  asset: registryAssetSchema,
+  namespace: namespaceSchema,
+  slug: slugSchema,
+  /** Null for unversioned resources (rules). */
+  version: docVersionSchema.nullable().default(null),
+  commitSha: external_exports.string(),
+  parentSha: external_exports.string().nullable().default(null),
+  source: registryPublishSourceSchema,
+  message: external_exports.string().default(""),
+  author: registryPublishAuthorSchema.nullable().default(null)
+}).meta({ id: "registry-publish" });
+
+// ../../packages/entities/dist/registry/version.js
+var docVersionToolSchema = external_exports.object({
+  path: external_exports.string(),
+  method: methodSchema,
+  enabledTools: external_exports.enum(["execute-request", "get-mini-openapi-spec"]).array()
+});
+var docEmbedStatusSchema = external_exports.enum(["complete", "failed"]);
+var docVersionRecordSchema = entitySchema.extend({
+  /** Own uid, branded so it cannot be confused with another entity's uid */
+  uid: brandedUid().default(mintUid).meta({ default: "nanoid()" }),
+  version: docVersionSchema,
+  /** OpenAPI version normalized on upload */
+  upgraded: external_exports.boolean().default(false),
+  /**
+   * Endpoints (path + method pairs) counted from the document at ingest.
+   * Null when the count is unknown: rows minted before this field existed,
+   * heal-path rows created without a fresh parse, and non-OpenAPI documents.
+   * Feeds the included-SDK-size display; measure-and-warn only.
+   */
+  endpointCount: external_exports.number().int().nullable().default(null),
+  embedStatus: docEmbedStatusSchema.nullable().default(null),
+  tags: external_exports.string().array().default([]),
+  /**
+   * Null is a legitimate stored state, not just absence: zod keeps optional
+   * keys explicitly passed as `undefined`, and a driver without
+   * `ignoreUndefined` stores those as BSON null. Records written that way
+   * carry `tools: null`, and rejecting it silently drops the whole record
+   * from egress — so null parses like "no tools configured".
+   */
+  tools: docVersionToolSchema.array().nullish()
+}).meta({ id: "doc-version-record" });
+
+// ../../packages/entities/dist/registry/pages.js
+var PAGES_SCHEMA_VERSION = 1;
+var pagesNavigationEntrySchema = external_exports.looseObject({
+  id: external_exports.string(),
+  title: external_exports.string().default(""),
+  type: external_exports.string(),
+  get children() {
+    return external_exports.array(pagesNavigationEntrySchema).optional();
+  }
+});
+var pagesEntrySchema = external_exports.object({
+  /** The navigation entry's `type`, e.g. `operation`, `webhook`, `model`. */
+  type: external_exports.string(),
+  method: external_exports.string().optional(),
+  path: external_exports.string().optional(),
+  /** JSON pointer the entry renders, for the entry types that carry one. */
+  ref: external_exports.string().optional()
+}).meta({ id: "pages-entry" });
+var pagesCountsSchema = external_exports.object({
+  operations: external_exports.number().int().min(0).default(0),
+  webhooks: external_exports.number().int().min(0).default(0),
+  models: external_exports.number().int().min(0).default(0),
+  tags: external_exports.number().int().min(0).default(0),
+  /** Objects written under `chunks/`, which is every entry with a page. */
+  chunks: external_exports.number().int().min(0).default(0)
+}).meta({ id: "pages-counts" });
+var pagesManifestSchema = external_exports.object({
+  schemaVersion: external_exports.literal(PAGES_SCHEMA_VERSION),
+  /** Content identity of the instance this sidecar was derived from. */
+  jsonSha: contentShaSchema,
+  producedAt: timestampSchema,
+  counts: pagesCountsSchema,
+  /**
+   * The document with its operation-bearing buckets emptied — the base every
+   * page starts from, before its own chunk is merged in.
+   */
+  stripped: external_exports.record(external_exports.string(), external_exports.unknown()),
+  /**
+   * The navigation tree, with the Models group's children dropped: a large
+   * document has thousands of them, and they are served separately by
+   * `pagesModels` on first expand.
+   */
+  navigation: external_exports.array(pagesNavigationEntrySchema),
+  /** Navigation id to what it renders, for routing without walking the tree. */
+  entries: external_exports.record(external_exports.string(), pagesEntrySchema)
+}).meta({ id: "pages-manifest" });
+var pagesPreparingSchema = external_exports.object({
+  jsonSha: contentShaSchema,
+  claimedAt: timestampSchema,
+  /** Which producer holds the claim, so a stale takeover is attributable. */
+  instance: external_exports.string().default("")
+}).meta({ id: "pages-preparing" });
+var pagesFailedSchema = external_exports.object({
+  jsonSha: contentShaSchema,
+  failedAt: timestampSchema,
+  /** Operator-facing reason; surfaced to the client only as a failure. */
+  error: external_exports.string().default("")
+}).meta({ id: "pages-failed" });
+
+// ../../packages/entities/dist/registry/token.js
+var registryTokenPayloadSchema = external_exports.object({
+  /** The team whose registry documents this token may read. */
+  teamUid: nanoidSchema,
+  exp: external_exports.number().int()
+}).meta({ id: "registry-token-payload" });
+
+export {
+  contentShaSchema,
+  docInstanceSchema,
+  RegistryResourceTypes,
+  registryGitBindingSchema,
+  docSourceSchema,
+  baseRegistrySchema,
+  registryPublishRecordSchema,
+  docVersionToolSchema,
+  docVersionRecordSchema
+};

package/chunks/{chunk-X4QLDBB5.js → chunk-T5HJUAWB.js}

@@ -72,10 +72,28 @@ var levelPrefixes = {
   warn: "[WARN]",
   error: "[ERROR]"
 };
+var stdoutManager;
+var stderrManager;
+function getManager(level) {
+  if (level === "error") {
+    if (!stderrManager) {
+      stderrManager = new UpdateManager(process.stderr, process.stderr);
+    }
+    return stderrManager;
+  }
+  if (!stdoutManager) {
+    stdoutManager = new UpdateManager(
+      process.stdout,
+      process.stdout
+    );
+  }
+  return stdoutManager;
+}
 var outputFactory = (level) => (options) => {
   const titlePrefix = levelPrefixes[level];
   const cl = levelColors[level];
-  const manager = UpdateManager.getInstance();
+  const manager = getManager(level);
+  const stream = level === "error" ? process.stderr : process.stdout;
   const state = [];
   let i = 0;
   const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
@@ -87,7 +105,10 @@ var outputFactory = (level) => (options) => {
           return cl(as.bold(`${titlePrefix} ${it.content}`));
         }
         if (it.type === "loader") {
-          return complete ? cl(`\u2714 ${it.content}`) : cl(`${frames[i % frames.length]} ${it.content}`);
+          if (!complete) {
+            return cl(`${frames[i % frames.length]} ${it.content}`);
+          }
+          return it.status === "error" ? as.red(`\u2716 ${it.content}`) : cl(`\u2714 ${it.content}`);
         }
         if (it.type === "table") {
           return it.content.map((it2) => cl(it2.join(""))).join("\n");
@@ -102,7 +123,7 @@ var outputFactory = (level) => (options) => {
   }, options?.frameRate ?? 100);
   function end() {
     update(true);
-    process.stdout.write("");
+    stream.write("");
     manager.unhook();
     clearInterval(interval);
     return { state };

package/chunks/{chunk-NUXPNUSS.js → chunk-UGGNHILG.js}

@@ -1,7 +1,7 @@
 import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
 import {
   registryUrl
-} from "./chunk-T7MDADON.js";
+} from "./chunk-COBPBRQF.js";
 
 // src/domains/registry/helpers/fetch.ts
 async function fetchFromRegistry(path, accessToken) {