tileflow 0.1.0-alpha.20 → 0.1.0-alpha.22

package/dist/chunk-5QK6JCLT.js

@@ -0,0 +1,2145 @@
+// src/account-session.ts
+import { randomBytes } from "crypto";
+import { chmod, mkdir, open, readFile, rename, unlink } from "fs/promises";
+import { homedir } from "os";
+import { dirname, resolve } from "path";
+import { z } from "zod";
+var rejectedAccountSessionMessage = "The saved Tileflow account session is no longer valid. Run tileflow login to authorize this machine again.";
+var maximumAuthFileBytes = 1024 * 1024;
+var maximumOrigins = 16;
+var accountSchema = z.object({
+  email: z.email().max(320),
+  id: z.string().min(1).max(200),
+  name: z.string().min(1).max(200)
+}).strict();
+var apiOriginSchema = z.url().max(2048).refine((value) => normalizeApiOrigin(value) === value);
+var sessionSchema = z.object({
+  account: accountSchema,
+  accountSession: z.string().regex(/^tf_session_[0-9a-f]{64}$/u),
+  apiOrigin: apiOriginSchema,
+  createdAt: z.iso.datetime({ offset: true }),
+  expiresAt: z.iso.datetime({ offset: true }),
+  sessionId: z.string().min(1).max(200)
+}).strict().refine((value) => Date.parse(value.expiresAt) > Date.parse(value.createdAt), {
+  message: "session expiry must follow creation"
+});
+var authConfigSchema = z.object({
+  sessions: z.record(z.string().max(2048), sessionSchema),
+  version: z.literal(2)
+}).strict().superRefine((value, context) => {
+  if (Object.keys(value.sessions).length > maximumOrigins) {
+    context.addIssue({ code: "custom", message: "too many API origins", path: ["sessions"] });
+  }
+  for (const [origin, session] of Object.entries(value.sessions)) {
+    if (normalizeApiOrigin(origin) !== origin || session.apiOrigin !== origin) {
+      context.addIssue({ code: "custom", message: "origin mismatch", path: ["sessions", origin] });
+    }
+  }
+});
+var legacyAuthConfigSchema = z.object({
+  apiKey: z.string().min(1).max(4096),
+  apiUrl: z.url().max(2048).refine((value) => {
+    try {
+      normalizeApiOrigin(value);
+      return true;
+    } catch {
+      return false;
+    }
+  })
+}).strict();
+function emptyAuthConfig() {
+  return Object.freeze({ sessions: Object.freeze({}), version: 2 });
+}
+async function readAuthFile(path = authConfigPath()) {
+  let source;
+  try {
+    source = await readFile(path, "utf8");
+  } catch (error) {
+    return isMissingFile(error) ? { kind: "empty" } : { kind: "invalid" };
+  }
+  if (Buffer.byteLength(source, "utf8") > maximumAuthFileBytes) return { kind: "invalid" };
+  let parsed;
+  try {
+    parsed = JSON.parse(source);
+  } catch {
+    return { kind: "invalid" };
+  }
+  const config = authConfigSchema.safeParse(parsed);
+  if (config.success) return { config: freezeConfig(config.data), kind: "sessions" };
+  return legacyAuthConfigSchema.safeParse(parsed).success ? { kind: "legacy" } : { kind: "invalid" };
+}
+async function prepareAccountLogin(path = authConfigPath()) {
+  const state = await readAuthFile(path);
+  if (state.kind === "invalid") {
+    throw new Error("Tileflow auth state is invalid; no changes were made.");
+  }
+  const directory = dirname(path);
+  const probePath = `${path}.tmp-${process.pid}-${randomBytes(8).toString("hex")}`;
+  await mkdir(directory, { mode: 448, recursive: true });
+  const handle = await open(probePath, "wx", 384);
+  try {
+    await handle.sync();
+  } finally {
+    await handle.close();
+    await unlink(probePath);
+  }
+  return state;
+}
+async function loadAuthConfig(path = authConfigPath()) {
+  const state = await readAuthFile(path);
+  if (state.kind === "empty") return emptyAuthConfig();
+  if (state.kind === "sessions") return state.config;
+  if (state.kind === "legacy") {
+    throw new Error(
+      "Tileflow CLI login uses an older format. Run tileflow login to sign in again."
+    );
+  }
+  throw new Error("Tileflow auth state is invalid; no changes were made.");
+}
+async function installAccountSession(session, path = authConfigPath()) {
+  const normalized = sessionSchema.parse({
+    ...session,
+    apiOrigin: normalizeApiOrigin(session.apiOrigin)
+  });
+  const state = await readAuthFile(path);
+  if (state.kind === "invalid") {
+    throw new Error("Tileflow auth state is invalid; no changes were made.");
+  }
+  const current = state.kind === "sessions" ? state.config : emptyAuthConfig();
+  const sessions = { ...current.sessions, [normalized.apiOrigin]: normalized };
+  if (Object.keys(sessions).length > maximumOrigins) {
+    throw new Error("Tileflow CLI API-origin limit reached.");
+  }
+  const config = freezeConfig({ sessions, version: 2 });
+  await writeAuthFileAtomic(config, path);
+  return config;
+}
+function resolveAccountSession(config, apiUrl, now = /* @__PURE__ */ new Date()) {
+  const origin = normalizeApiOrigin(apiUrl);
+  const session = config.sessions[origin];
+  if (!session) return { kind: "missing" };
+  return Date.parse(session.expiresAt) <= now.getTime() ? { kind: "expired" } : { kind: "selected", origin, session };
+}
+function removeAccountSession(config, apiUrl) {
+  const origin = normalizeApiOrigin(apiUrl);
+  const sessions = { ...config.sessions };
+  const removed = sessions[origin];
+  delete sessions[origin];
+  return { config: freezeConfig({ sessions, version: 2 }), removed };
+}
+async function writeAuthFileAtomic(config, path = authConfigPath()) {
+  const normalized = normalizeConfig(authConfigSchema.parse(config));
+  const source = `${JSON.stringify(normalized, null, 2)}
+`;
+  if (Buffer.byteLength(source, "utf8") > maximumAuthFileBytes) {
+    throw new Error("Tileflow auth state exceeds its safe size limit.");
+  }
+  const directory = dirname(path);
+  const temporaryPath = `${path}.tmp-${process.pid}-${randomBytes(8).toString("hex")}`;
+  await mkdir(directory, { mode: 448, recursive: true });
+  await chmod(directory, 448);
+  let handle;
+  try {
+    handle = await open(temporaryPath, "wx", 384);
+    await handle.writeFile(source, "utf8");
+    await handle.sync();
+    await handle.close();
+    handle = void 0;
+    await chmod(temporaryPath, 384);
+    await rename(temporaryPath, path);
+    await chmod(path, 384);
+    await syncDirectory(directory);
+  } catch (error) {
+    await handle?.close().catch(() => void 0);
+    await unlink(temporaryPath).catch(() => void 0);
+    throw error;
+  }
+}
+async function removeAuthFile(path = authConfigPath()) {
+  await unlink(path).catch((error) => {
+    if (!isMissingFile(error)) throw error;
+  });
+}
+function normalizeApiOrigin(value) {
+  const url = new URL(value);
+  if (url.protocol !== "https:" && url.protocol !== "http:" || url.username || url.password || url.search || url.hash || url.pathname !== "/" && url.pathname !== "") {
+    throw new Error("Tileflow API URL must be a safe HTTP origin.");
+  }
+  return url.origin;
+}
+function parseProjectReference(value) {
+  if (typeof value !== "string") return null;
+  const match = /^@([A-Za-z0-9][A-Za-z0-9._-]{0,127})\/([A-Za-z0-9][A-Za-z0-9._-]{0,127})$/u.exec(
+    value
+  );
+  return match ? { organizationSlug: match[1], projectSlug: match[2] } : null;
+}
+function authConfigPath() {
+  return resolve(homedir(), ".tileflow", "config.json");
+}
+function normalizeConfig(config) {
+  return {
+    sessions: Object.fromEntries(
+      Object.entries(config.sessions).sort(([left], [right]) => compareCodeUnits(left, right)).map(([origin, session]) => [origin, { ...session, apiOrigin: origin }])
+    ),
+    version: 2
+  };
+}
+function freezeConfig(config) {
+  const normalized = normalizeConfig(config);
+  const sessions = Object.fromEntries(
+    Object.entries(normalized.sessions).map(([origin, session]) => [
+      origin,
+      Object.freeze({ ...session, account: Object.freeze({ ...session.account }) })
+    ])
+  );
+  return Object.freeze({ sessions: Object.freeze(sessions), version: 2 });
+}
+async function syncDirectory(path) {
+  if (process.platform === "win32") return;
+  const directory = await open(path, "r");
+  try {
+    await directory.sync();
+  } finally {
+    await directory.close();
+  }
+}
+function isMissingFile(error) {
+  return Boolean(
+    error && typeof error === "object" && error.code === "ENOENT"
+  );
+}
+function compareCodeUnits(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+// src/cli-program.ts
+import { Command } from "commander";
+import pc from "picocolors";
+function createCliProgram() {
+  return new Command().name("tileflow").description("Beautiful maps from config.").enablePositionalOptions().showHelpAfterError(pc.gray("\nRun tileflow <command> --help for usage.")).showSuggestionAfterError().addHelpText("after", "\n  -V, --version  output the version number\n");
+}
+
+// src/hosted-options.ts
+import { Option } from "commander";
+function hostedApiKeyOption(description = "Tileflow API key") {
+  return new Option("--api-key <key>", description).env("TILEFLOW_API_KEY");
+}
+function hostedApiUrlOption() {
+  return new Option("--api-url <url>", "Tileflow API URL").env("TILEFLOW_API_URL");
+}
+function isHostedApiKey(value) {
+  return /^tf_live_[0-9a-f]{48}$/u.test(value);
+}
+function allowsStoredAccountSession(env = process.env) {
+  return !env.CI && env.GITHUB_ACTIONS !== "true" && env.GITLAB_CI !== "true";
+}
+
+// src/hosted-client.ts
+import { serializeTileflowFontBundleManifest } from "@tileflow/core";
+import { compactTileflowDeploymentArtifact, tileflowDeploymentWebBytes } from "@tileflow/core/build";
+
+// src/hosted-response.ts
+import { z as z2 } from "zod";
+import { tileflowIconPackageLimits } from "@tileflow/core";
+var maximumHostedResponseBytes = 1024 * 1024;
+var safeTextSchema = z2.string().min(1).max(300).refine((value) => !/[\p{Cc}]/u.test(value));
+var safeIdentifierSchema = z2.string().min(1).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/u);
+var safeStorageKeySchema = z2.string().min(1).max(512).regex(/^[A-Za-z0-9][A-Za-z0-9._:/-]*$/u).refine((value) => value.split("/").every((segment) => segment !== "." && segment !== ".."));
+var publicHttpUrlSchema = z2.url().max(2048).refine((value) => {
+  const url = new URL(value);
+  return (url.protocol === "http:" || url.protocol === "https:") && !url.username && !url.password && !url.hash;
+});
+var hostedStyleDeploymentResponseSchema = z2.object({
+  changed: z2.boolean().optional(),
+  deploymentId: safeIdentifierSchema.optional(),
+  mapId: z2.string().regex(/^map_[A-Za-z0-9_-]{16}$/u),
+  familyUrl: publicHttpUrlSchema.optional(),
+  themes: z2.record(
+    safeIdentifierSchema,
+    z2.object({
+      styleId: safeIdentifierSchema.optional(),
+      styleUrl: publicHttpUrlSchema
+    }).strict()
+  ).refine((themes) => Object.keys(themes).length > 0),
+  version: z2.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional(),
+  /**
+   * The Team 3D models the map places, each at its published current version, and whether that
+   * version was prepared from the same glTF binaries as the map's own files.
+   */
+  teamModels: z2.array(
+    z2.object({
+      model: z2.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/u).max(64),
+      version: z2.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+      sources: z2.enum(["match", "differ", "unknown"])
+    }).strict()
+  ).max(256).optional()
+}).strict();
+var hostedIconPackageResponseSchema = z2.object({
+  changed: z2.boolean().optional(),
+  contentHash: z2.string().regex(/^[a-f0-9]{64}$/u),
+  iconCount: z2.number().int().positive().max(tileflowIconPackageLimits.maxIconCount),
+  id: z2.string().regex(/^icp_[A-Za-z0-9_-]{16,64}$/u),
+  spriteUrl: publicHttpUrlSchema,
+  totalBytes: z2.number().int().positive().max(Number.MAX_SAFE_INTEGER)
+});
+var hostedFontBundleResponseSchema = z2.object({
+  baseUrl: publicHttpUrlSchema,
+  changed: z2.boolean().optional(),
+  contentHash: z2.string().regex(/^[a-f0-9]{64}$/u),
+  fontFaceCount: z2.number().int().positive().max(16),
+  id: z2.string().regex(/^fnb_[A-Za-z0-9_-]{16,64}$/u),
+  totalBytes: z2.number().int().positive().max(Number.MAX_SAFE_INTEGER)
+});
+var hostedStatusStyleSchema = z2.object({
+  environment: safeTextSchema,
+  key: safeStorageKeySchema,
+  mapId: safeIdentifierSchema,
+  size: z2.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+  uploaded: z2.iso.datetime({ offset: true })
+});
+var hostedMapStatusSchema = z2.object({
+  mapId: z2.string().regex(/^map_[A-Za-z0-9_-]{16}$/u),
+  styles: z2.array(hostedStatusStyleSchema).max(1e4)
+});
+async function readBoundedResponseText(response, label) {
+  const contentLength = response.headers.get("content-length");
+  if (contentLength && /^\d+$/u.test(contentLength) && Number(contentLength) > maximumHostedResponseBytes) {
+    throw new Error(`${label} response exceeded the safe size limit.`);
+  }
+  if (!response.body) return "";
+  const reader = response.body.getReader();
+  const chunks = [];
+  let byteLength = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!value) continue;
+      byteLength += value.byteLength;
+      if (byteLength > maximumHostedResponseBytes) {
+        await reader.cancel().catch(() => void 0);
+        throw new Error(`${label} response exceeded the safe size limit.`);
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(byteLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    throw new Error(`${label} returned invalid UTF-8.`);
+  }
+}
+
+// src/hosted-client.ts
+var defaultHostedRequestTimeoutMs = 3e4;
+var maximumHostedRequestTimeoutMs = 6e4;
+function apiProfileCanTargetMap(profile, mapId) {
+  if (!/^map_[A-Za-z0-9_-]{16}$/u.test(mapId)) return false;
+  return profile.credentialType === "project_api_key" ? profile.mapId === mapId : profile.mapAccess?.mode === "all" || profile.mapAccess?.mode === "selected" && profile.mapAccess.ids.includes(mapId);
+}
+async function requestHostedJson(apiUrl, path, init = {}, options = {}) {
+  return withHostedResponse(apiUrl, path, init, options, async (response) => {
+    const retryAfter = response.headers.get("retry-after");
+    const retryAfterMs = retryAfter === null ? void 0 : /^\d+$/u.test(retryAfter) ? Number(retryAfter) * 1e3 : Math.max(0, Date.parse(retryAfter) - Date.now());
+    const metadata = {
+      ok: response.ok,
+      status: response.status,
+      ...Number.isFinite(retryAfterMs) ? { retryAfterMs } : {}
+    };
+    const source = await readBoundedResponseText(response, "Hosted API");
+    if (!source) return { body: null, json: true, ...metadata };
+    try {
+      return {
+        body: JSON.parse(source),
+        json: true,
+        ...metadata
+      };
+    } catch {
+      return { body: null, json: false, ...metadata };
+    }
+  });
+}
+async function startDeviceAuthorization(appUrl, body, options = {}) {
+  const response = await requestHostedJson(
+    appUrl,
+    "/api/cli/device/start",
+    jsonRequest("POST", body),
+    options
+  );
+  if (!response.ok) {
+    throw new Error(`Could not start CLI authorization (${response.status}).`);
+  }
+  if (!isDeviceAuthorization(response.body)) {
+    throw new Error("Could not start CLI authorization (invalid response).");
+  }
+  const appOrigin = normalizeApiOrigin(appUrl);
+  if (new URL(response.body.verificationUri).origin !== appOrigin || new URL(response.body.verificationUriComplete).origin !== appOrigin) {
+    throw new Error("Could not start CLI authorization (unexpected verification origin).");
+  }
+  return response.body;
+}
+async function pollDeviceToken(appUrl, authorization, input, options = {}) {
+  const now = input.now ?? Date.now;
+  const expiresAt = input.expiresAt ?? now() + authorization.expiresIn * 1e3;
+  let intervalMs = Math.max(authorization.interval, 1) * 1e3;
+  let delayMs = intervalMs;
+  const wait = input.sleep ?? ((milliseconds) => new Promise((resolve2) => setTimeout(resolve2, milliseconds)));
+  while (now() < expiresAt) {
+    options.signal?.throwIfAborted();
+    await wait(Math.min(delayMs, expiresAt - now()));
+    options.signal?.throwIfAborted();
+    if (now() >= expiresAt) break;
+    let response;
+    try {
+      response = await requestHostedJson(
+        appUrl,
+        "/api/cli/device/token",
+        jsonRequest("POST", {
+          codeVerifier: input.codeVerifier,
+          deviceCode: authorization.deviceCode
+        }),
+        {
+          ...options,
+          timeoutMs: Math.min(
+            options.timeoutMs ?? defaultHostedRequestTimeoutMs,
+            expiresAt - now()
+          )
+        }
+      );
+    } catch (error2) {
+      options.signal?.throwIfAborted();
+      if (!(error2 instanceof TypeError) && !(error2 instanceof Error && error2.name === "TimeoutError"))
+        throw error2;
+      delayMs = Math.min(Math.max(delayMs * 2, intervalMs), 6e4);
+      continue;
+    }
+    if (response.ok && isDeviceToken(response.body)) return response.body;
+    const error = asRecord(response.body).error;
+    if (error === "access_denied") throw new Error("CLI authorization was denied.");
+    if (error === "expired_token") break;
+    if (error === "slow_down" || response.status === 429) {
+      intervalMs += 5e3;
+      delayMs = Math.max(intervalMs, response.retryAfterMs ?? 0);
+      continue;
+    }
+    if (error === "authorization_pending") {
+      delayMs = intervalMs;
+      continue;
+    }
+    if ([408, 500, 502, 503, 504].includes(response.status)) {
+      delayMs = Math.max(Math.min(delayMs * 2, 6e4), response.retryAfterMs ?? 0);
+      continue;
+    }
+    throw new Error(`CLI authorization failed (${response.status}).`);
+  }
+  throw new Error("CLI authorization expired. Run `tileflow login` again.");
+}
+async function validateAccountSession(session, options = {}) {
+  const response = await requestHostedJson(
+    session.apiOrigin,
+    "/v1/cli/account",
+    { headers: authorizationHeaders(session.accountSession) },
+    options
+  );
+  if (!response.ok) {
+    return {
+      error: response.status === 401 ? rejectedAccountSessionMessage : `Account session validation failed (${response.status}).`,
+      ok: false
+    };
+  }
+  const body = asRecord(response.body);
+  const account = asRecord(body.account);
+  const sessionProfile = asRecord(body.session);
+  if (!response.json || body.schemaVersion !== 1 || !isAccountIdentity(account) || typeof sessionProfile.id !== "string" || sessionProfile.id !== session.sessionId || !validIsoDate(sessionProfile.expiresAt) || sessionProfile.expiresAt !== session.expiresAt || Object.hasOwn(body, "project")) {
+    return { error: "Account session validation returned an invalid response.", ok: false };
+  }
+  return {
+    ok: true,
+    value: {
+      account,
+      session: { expiresAt: sessionProfile.expiresAt, id: sessionProfile.id }
+    }
+  };
+}
+async function validateApiKey(apiUrl, apiKey, options = {}) {
+  const response = await requestHostedJson(
+    apiUrl,
+    "/v1/me",
+    { headers: authorizationHeaders(apiKey) },
+    options
+  );
+  if (!response.ok) {
+    return { error: `API key validation failed (${response.status}).`, ok: false };
+  }
+  const body = asRecord(response.body);
+  if (response.json && body.credentialType === "team_api_key") {
+    const mapAccess = asRecord(body.mapAccess);
+    const validMaps = body.mapAccess === null || mapAccess.mode === "all" && Object.keys(mapAccess).length === 1 || mapAccess.mode === "selected" && Object.keys(mapAccess).length === 2 && Array.isArray(mapAccess.ids) && mapAccess.ids.length > 0 && mapAccess.ids.length <= 1e3 && mapAccess.ids.every(
+      (id) => typeof id === "string" && /^map_[A-Za-z0-9_-]{16}$/u.test(id)
+    ) && new Set(mapAccess.ids).size === mapAccess.ids.length;
+    if (typeof body.apiKeyId !== "string" || !isProjectIdentity(body.organization) || body.project !== null || body.projectId !== null || body.mapId !== null || !validMaps || !Array.isArray(body.scopes) || !body.scopes.every((scope) => typeof scope === "string")) {
+      return { error: "API key validation returned an invalid response.", ok: false };
+    }
+    return {
+      ok: true,
+      value: {
+        apiKeyId: body.apiKeyId,
+        credentialType: "team_api_key",
+        organization: body.organization,
+        mapId: null,
+        project: null,
+        projectId: null,
+        scopes: body.scopes,
+        mapAccess: body.mapAccess === null ? null : mapAccess.mode === "all" ? { mode: "all" } : { mode: "selected", ids: mapAccess.ids }
+      }
+    };
+  }
+  if (!response.json || typeof body.apiKeyId !== "string" || body.credentialType !== "project_api_key" || typeof body.mapId !== "string" || !/^map_[A-Za-z0-9_-]{16}$/u.test(body.mapId) || !isProjectIdentity(body.organization) || !isProjectIdentity(body.project) || typeof body.projectId !== "string" || body.projectId !== body.project.id || !Array.isArray(body.scopes)) {
+    return { error: "API key validation returned an invalid response.", ok: false };
+  }
+  return {
+    ok: true,
+    value: {
+      apiKeyId: body.apiKeyId,
+      credentialType: body.credentialType,
+      mapId: body.mapId,
+      organization: body.organization,
+      project: body.project,
+      projectId: body.projectId,
+      scopes: body.scopes.filter((scope) => typeof scope === "string")
+    }
+  };
+}
+async function requestMapCapability(session, target, scopes, options = {}) {
+  let response;
+  try {
+    response = await requestHostedJson(
+      session.apiOrigin,
+      "/v1/cli/map-capabilities",
+      {
+        ...jsonRequest("POST", { ...target, scopes }),
+        headers: {
+          ...authorizationHeaders(session.accountSession),
+          "Content-Type": "application/json"
+        }
+      },
+      options
+    );
+  } catch (error) {
+    return { error: safeTransportError(error, "Map capability request failed."), ok: false };
+  }
+  if (!response.ok) {
+    return {
+      error: response.status === 401 ? rejectedAccountSessionMessage : `Map capability request failed (${response.status}).`,
+      ok: false
+    };
+  }
+  const body = asRecord(response.body);
+  if (!response.json || typeof body.capability !== "string" || !body.capability.startsWith("tf_cap_") || body.capability.length > 8192 || typeof body.mapId !== "string" || !/^map_[A-Za-z0-9_-]{16}$/u.test(body.mapId) || body.mapId !== target.mapId || !validIsoDate(body.expiresAt) || !Array.isArray(body.scopes) || body.scopes.join("\0") !== [...scopes].sort().join("\0")) {
+    return { error: "Map capability response was invalid.", ok: false };
+  }
+  return { capability: body.capability, mapId: body.mapId, ok: true };
+}
+async function requestTeamCapability(session, team, scopes, options = {}) {
+  let response;
+  try {
+    response = await requestHostedJson(
+      session.apiOrigin,
+      "/v1/cli/team-capabilities",
+      {
+        ...jsonRequest("POST", { scopes, team }),
+        headers: {
+          ...authorizationHeaders(session.accountSession),
+          "Content-Type": "application/json"
+        }
+      },
+      options
+    );
+  } catch (error) {
+    return { error: safeTransportError(error, "Team capability request failed."), ok: false };
+  }
+  if (!response.ok) {
+    return { error: `Team capability request failed (${response.status}).`, ok: false };
+  }
+  const body = asRecord(response.body);
+  if (!response.json || body.schemaVersion !== 1 || typeof body.capability !== "string" || !body.capability.startsWith("tf_cap_") || body.capability.length > 8192 || body.reference !== team || !isProjectIdentity(body.team) || `@${body.team.slug}` !== team || !validIsoDate(body.expiresAt) || !Array.isArray(body.scopes) || body.scopes.join("\0") !== [...scopes].sort().join("\0")) {
+    return { error: "Team capability response was invalid.", ok: false };
+  }
+  return { capability: body.capability, expiresAt: body.expiresAt, ok: true, team: body.team };
+}
+async function listAccountTeams(session, options = {}) {
+  const response = await requestHostedJson(
+    session.apiOrigin,
+    "/v1/cli/teams",
+    { headers: authorizationHeaders(session.accountSession) },
+    options
+  );
+  const body = asRecord(response.body);
+  if (!response.ok) return { error: `Team discovery failed (${response.status}).`, ok: false };
+  if (!response.json || body.schemaVersion !== 1 || !Array.isArray(body.teams) || !body.teams.every(isProjectIdentity)) {
+    return { error: "Team discovery returned an invalid response.", ok: false };
+  }
+  const teams = [...body.teams].sort(
+    (left, right) => left.slug < right.slug ? -1 : left.slug > right.slug ? 1 : 0
+  );
+  if (new Set(teams.map(({ id }) => id)).size !== teams.length || teams.some((team, index) => index > 0 && teams[index - 1].slug >= team.slug)) {
+    return { error: "Team discovery returned unstable ordering.", ok: false };
+  }
+  return { ok: true, teams };
+}
+async function listMapSetupTeams(session, options = {}) {
+  let response;
+  try {
+    response = await requestHostedJson(
+      session.apiOrigin,
+      "/v1/cli/map-setup/teams",
+      { headers: authorizationHeaders(session.accountSession) },
+      options
+    );
+  } catch (error) {
+    return { error: safeTransportError(error, "Team discovery failed."), ok: false };
+  }
+  if (!response.ok) {
+    return {
+      error: response.status === 401 ? rejectedAccountSessionMessage : `Team discovery failed (${response.status}).`,
+      ok: false
+    };
+  }
+  const body = asRecord(response.body);
+  if (!response.json || body.schemaVersion !== 1 || !Array.isArray(body.teams) || !body.teams.every(isMapSetupTeam)) {
+    return { error: "Team discovery returned an invalid response.", ok: false };
+  }
+  return { ok: true, teams: body.teams };
+}
+async function createManagedMapSetup(session, input, options = {}) {
+  let response;
+  try {
+    response = await requestHostedJson(
+      session.apiOrigin,
+      "/v1/cli/maps",
+      {
+        ...jsonRequest("POST", input),
+        headers: {
+          ...authorizationHeaders(session.accountSession),
+          "Content-Type": "application/json"
+        }
+      },
+      options
+    );
+  } catch (error) {
+    return {
+      code: "setup_failed",
+      error: safeTransportError(error, "Map setup request failed."),
+      ok: false
+    };
+  }
+  const body = asRecord(response.body);
+  if (!response.ok) {
+    if (response.status === 401) {
+      return { code: "account_session_rejected", error: rejectedAccountSessionMessage, ok: false };
+    }
+    const code = mapSetupFailureMessages[body.code] ? body.code : null;
+    return code ? { code, error: mapSetupFailureMessages[code], ok: false } : { code: "setup_failed", error: `Map setup failed (${response.status}).`, ok: false };
+  }
+  const map = asRecord(body.map);
+  const team = asRecord(body.team);
+  const delivery = asRecord(body.delivery);
+  if (!response.json || body.schemaVersion !== 1 || typeof map.id !== "string" || !/^map_[A-Za-z0-9_-]{16}$/u.test(map.id) || map.name !== null && typeof map.name !== "string" || map.state !== "setup_pending" && map.state !== "active" || typeof team.name !== "string" || `@${String(team.slug)}` !== input.team || !Array.isArray(delivery.allowedOrigins) || !delivery.allowedOrigins.every((origin) => typeof origin === "string") || delivery.allowedOrigins.length !== input.allowedOrigins.length) {
+    return { code: "setup_failed", error: "Map setup returned an invalid response.", ok: false };
+  }
+  return {
+    ok: true,
+    value: {
+      allowedOrigins: delivery.allowedOrigins,
+      map: { id: map.id, name: map.name, state: map.state },
+      team: { name: team.name, slug: team.slug }
+    }
+  };
+}
+var mapSetupFailureMessages = {
+  invalid_request: "Tileflow rejected the Map setup request.",
+  map_limit: "This Team has reached its Map limit. Archive or delete a Map, or change the plan, in the Tileflow dashboard.",
+  permission_required: "Only a Team Admin can create Maps.",
+  setup_conflict: "This setup key was already used with another Team or browser access choice. Omit --setup-key to start a new setup.",
+  team_not_found: "No Team you administer matches this Team."
+};
+function isMapSetupTeam(value) {
+  const team = asRecord(value);
+  return typeof team.eligible === "boolean" && typeof team.name === "string" && typeof team.slug === "string" && /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(team.slug) && (team.unavailableReason === void 0 || team.unavailableReason === "map_limit") && Object.keys(team).every(
+    (key) => ["eligible", "name", "slug", "unavailableReason"].includes(key)
+  );
+}
+async function publishHostedStyle(api, body, responseLabel, options = {}) {
+  const input = body;
+  const compactBody = { ...input, artifact: compactTileflowDeploymentArtifact(input.artifact) };
+  assertHostedStyleBudget(compactBody);
+  const response = await requestHostedJson(
+    api.apiUrl,
+    "/v1/styles",
+    {
+      ...jsonRequest("POST", compactBody),
+      headers: { ...authorizationHeaders(api.apiKey, api.mapId), "Content-Type": "application/json" }
+    },
+    options
+  );
+  if (!response.ok) return { ok: false, status: response.status };
+  return {
+    ok: true,
+    value: parseResponse(response, hostedStyleDeploymentResponseSchema, responseLabel)
+  };
+}
+function assertHostedStyleBudget(body) {
+  const observedBytes = tileflowDeploymentWebBytes(body);
+  const limitBytes = 2e6;
+  if (observedBytes > limitBytes)
+    throw Object.assign(
+      new Error(`Style content is ${observedBytes} bytes; the limit is ${limitBytes} bytes.`),
+      { code: "STYLE_DEPLOYMENT_TOO_LARGE", scope: "web", observedBytes, limitBytes }
+    );
+}
+async function uploadHostedIconPackage(api, iconPackage, options = {}) {
+  const formData = new FormData();
+  const fieldNames = {
+    "sprite.json": "spriteJson",
+    "sprite.png": "spritePng",
+    "sprite@2x.json": "sprite2xJson",
+    "sprite@2x.png": "sprite2xPng"
+  };
+  for (const file of iconPackage.files) {
+    const fieldName = fieldNames[file.fileName];
+    if (!fieldName) throw new Error(`Unknown generated icon package file: ${file.fileName}`);
+    const bytes = new Uint8Array(file.source.byteLength);
+    bytes.set(file.source);
+    formData.append(fieldName, new Blob([bytes.buffer], { type: file.contentType }), file.fileName);
+  }
+  const response = await requestHostedJson(
+    api.apiUrl,
+    `/v1/icon-packages/${encodeURIComponent(iconPackage.contentHash)}`,
+    { body: formData, headers: authorizationHeaders(api.apiKey, api.mapId), method: "PUT" },
+    options
+  );
+  if (!response.ok) return { ok: false, status: response.status };
+  const value = parseResponse(
+    response,
+    hostedIconPackageResponseSchema,
+    "Icon package upload response"
+  );
+  const publicSpriteUrl = new URL(value.spriteUrl);
+  if (value.contentHash !== iconPackage.contentHash || value.iconCount !== iconPackage.manifest.iconNames.length || value.totalBytes !== iconPackage.manifest.files.reduce((total, file) => total + file.byteLength, 0) || publicSpriteUrl.pathname !== `/sprites/${value.id}/sprite` || publicSpriteUrl.search !== "") {
+    throw new Error("Icon package upload response did not confirm the submitted package.");
+  }
+  return { ok: true, value };
+}
+async function uploadHostedFontBundle(api, bundle, options = {}) {
+  const formData = new FormData();
+  formData.append(
+    "manifest",
+    new Blob([serializeTileflowFontBundleManifest(bundle.manifest)], {
+      type: "application/json"
+    }),
+    "manifest.json"
+  );
+  for (const file of bundle.files) {
+    const source = typeof file.source === "string" ? new TextEncoder().encode(file.source) : file.source;
+    const bytes = new Uint8Array(source.byteLength);
+    bytes.set(source);
+    formData.append(
+      `file:${encodeURIComponent(file.fileName)}`,
+      new Blob([bytes.buffer], { type: file.contentType }),
+      file.fileName.split("/").at(-1)
+    );
+  }
+  const response = await requestHostedJson(
+    api.apiUrl,
+    `/v1/font-bundles/${encodeURIComponent(bundle.contentHash)}`,
+    { body: formData, headers: authorizationHeaders(api.apiKey, api.mapId), method: "PUT" },
+    options
+  );
+  if (!response.ok) return { ok: false, status: response.status };
+  const value = parseResponse(
+    response,
+    hostedFontBundleResponseSchema,
+    "Font bundle upload response"
+  );
+  const publicBaseUrl = new URL(value.baseUrl);
+  if (value.contentHash !== bundle.contentHash || value.fontFaceCount !== bundle.manifest.fontFaces.length || value.totalBytes !== bundle.manifest.files.reduce((total, file) => total + file.byteLength, 0) || publicBaseUrl.pathname !== `/font-bundles/${value.id}` || publicBaseUrl.search !== "") {
+    throw new Error("Font bundle upload response did not confirm the submitted bundle.");
+  }
+  return { ok: true, value };
+}
+async function fetchHostedMapStatus(api, options = {}) {
+  const response = await requestHostedJson(
+    api.apiUrl,
+    "/v1/status",
+    { headers: authorizationHeaders(api.apiKey, api.mapId) },
+    options
+  );
+  if (!response.ok) throw new Error(`Status failed: ${response.status}.`);
+  return parseResponse(response, hostedMapStatusSchema, "Status response");
+}
+async function revokeHostedAccountSession(apiUrl, accountSession, options = {}) {
+  try {
+    const response = await requestHostedJson(
+      apiUrl,
+      "/v1/cli/account/session",
+      { headers: authorizationHeaders(accountSession), method: "DELETE" },
+      options
+    );
+    return response.status === 401 || response.ok;
+  } catch {
+    return false;
+  }
+}
+async function withHostedResponse(apiUrl, path, init, options, consume) {
+  const origin = normalizeApiOrigin(apiUrl);
+  const url = resolveHostedRequestUrl(origin, path);
+  const timeoutMs = normalizeTimeout(options.timeoutMs);
+  const requestSignal = createRequestSignal(options.signal ?? init.signal ?? void 0, timeoutMs);
+  const requestFetch = options.fetch ?? globalThis.fetch;
+  const { signal: _ignoredSignal, ...requestInit } = init;
+  try {
+    const operation = Promise.resolve().then(
+      () => requestFetch(url, { ...requestInit, redirect: "error", signal: requestSignal.signal })
+    ).then(consume);
+    return await raceWithAbort(operation, requestSignal.signal);
+  } finally {
+    requestSignal.cleanup();
+  }
+}
+function raceWithAbort(operation, signal) {
+  if (signal.aborted) return Promise.reject(signal.reason);
+  return new Promise((resolve2, reject) => {
+    const cleanup = () => signal.removeEventListener("abort", onAbort);
+    const onAbort = () => {
+      cleanup();
+      reject(signal.reason);
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    operation.then(
+      (value) => {
+        cleanup();
+        resolve2(value);
+      },
+      (error) => {
+        cleanup();
+        reject(error);
+      }
+    );
+  });
+}
+function resolveHostedRequestUrl(origin, path) {
+  if (!path.startsWith("/") || path.startsWith("//") || /[\p{Cc}\\]/u.test(path)) {
+    throw new TypeError("Hosted API path must be a safe root-relative path.");
+  }
+  const url = new URL(path, origin);
+  if (url.origin !== origin || url.username || url.password || url.hash) {
+    throw new TypeError("Hosted API path must stay on the configured API origin.");
+  }
+  return url.toString();
+}
+function normalizeTimeout(value) {
+  if (value === void 0) return defaultHostedRequestTimeoutMs;
+  if (!Number.isFinite(value) || value < 1 || value > maximumHostedRequestTimeoutMs) {
+    throw new TypeError("Hosted request timeoutMs must be between 1 and 60000 milliseconds.");
+  }
+  return value;
+}
+function createRequestSignal(external, timeoutMs) {
+  const controller = new AbortController();
+  const abortFromExternal = () => controller.abort(external?.reason);
+  if (external?.aborted) abortFromExternal();
+  else external?.addEventListener("abort", abortFromExternal, { once: true });
+  const timeout = setTimeout(
+    () => controller.abort(new DOMException("Hosted request timed out", "TimeoutError")),
+    timeoutMs
+  );
+  return {
+    cleanup() {
+      clearTimeout(timeout);
+      external?.removeEventListener("abort", abortFromExternal);
+    },
+    signal: controller.signal
+  };
+}
+function jsonRequest(method, body) {
+  return {
+    body: JSON.stringify(body),
+    headers: { "Content-Type": "application/json" },
+    method
+  };
+}
+function authorizationHeaders(token, mapId) {
+  if (!token || token.length > 8192 || /[\p{Cc}]/u.test(token)) {
+    throw new TypeError("Hosted authorization credential is invalid.");
+  }
+  if (mapId !== void 0 && !/^map_[A-Za-z0-9_-]{16}$/u.test(mapId))
+    throw new TypeError("Hosted Map ID is invalid.");
+  return {
+    Authorization: `Bearer ${token}`,
+    ...mapId === void 0 ? {} : { "X-Tileflow-Map-Id": mapId }
+  };
+}
+function parseResponse(response, schema, label) {
+  if (!response.json) throw new Error(`${label} returned invalid JSON.`);
+  const parsed = schema.safeParse(response.body);
+  if (!parsed.success) throw new Error(`${label} returned an invalid response.`);
+  return parsed.data;
+}
+function isDeviceAuthorization(value) {
+  const authorization = asRecord(value);
+  return typeof authorization.apiUrl === "string" && safeOrigin(authorization.apiUrl) !== null && safeIdentifier(authorization.deviceCode, 512) && Number.isInteger(authorization.expiresIn) && authorization.expiresIn >= 1 && authorization.expiresIn <= 3600 && Number.isInteger(authorization.interval) && authorization.interval >= 1 && authorization.interval <= 60 && safeIdentifier(authorization.userCode, 64) && safePublicUrl(authorization.verificationUri) && safePublicUrl(authorization.verificationUriComplete);
+}
+function isDeviceToken(value) {
+  const token = asRecord(value);
+  return isAccountIdentity(token.account) && typeof token.accountSession === "string" && /^tf_session_[0-9a-f]{64}$/u.test(token.accountSession) && typeof token.apiUrl === "string" && safeOrigin(token.apiUrl) !== null && validIsoDate(token.createdAt) && validIsoDate(token.expiresAt) && Date.parse(token.expiresAt) > Date.parse(token.createdAt) && safeIdentifier(token.sessionId, 200) && !Object.hasOwn(token, "project");
+}
+function isProjectIdentity(value) {
+  const identity = asRecord(value);
+  return safeIdentifier(identity.id, 160) && safeText(identity.name, 200) && typeof identity.slug === "string" && /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(identity.slug);
+}
+function isAccountIdentity(value) {
+  const account = asRecord(value);
+  return safeIdentifier(account.id, 200) && safeText(account.name, 200) && typeof account.email === "string" && account.email.length > 2 && account.email.length <= 320 && account.email.includes("@") && !/[\p{Cc}]/u.test(account.email);
+}
+function safeIdentifier(value, maximum) {
+  return typeof value === "string" && value.length > 0 && value.length <= maximum && !/[\p{Cc}]/u.test(value);
+}
+function safeText(value, maximum) {
+  return safeIdentifier(value, maximum);
+}
+function safePublicUrl(value) {
+  if (typeof value !== "string" || value.length > 2048) return false;
+  try {
+    const url = new URL(value);
+    return (url.protocol === "http:" || url.protocol === "https:") && !url.username && !url.password && !url.hash;
+  } catch {
+    return false;
+  }
+}
+function safeOrigin(value) {
+  try {
+    return normalizeApiOrigin(value);
+  } catch {
+    return null;
+  }
+}
+function validIsoDate(value) {
+  return typeof value === "string" && value.length <= 64 && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/u.test(value) && Number.isFinite(Date.parse(value));
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function safeTransportError(error, fallback) {
+  if (error instanceof Error && /safe size limit|timed out/u.test(error.message)) {
+    return error.message;
+  }
+  return fallback;
+}
+
+// src/tileset-command.ts
+import pc3 from "picocolors";
+import { z as z4 } from "zod";
+import { serializeCanonicalJson as serializeCanonicalJson3 } from "@tileflow/core";
+import { inspectTileflowPmtiles } from "@tileflow/dev/tilesets";
+
+// src/hosted-team.ts
+import pc2 from "picocolors";
+import { serializeCanonicalJson } from "@tileflow/core";
+async function resolveTeamAuthority(options, scopes, dependencies) {
+  let apiOrigin;
+  try {
+    apiOrigin = normalizeApiOrigin(options.apiUrl ?? dependencies.defaultApiUrl);
+  } catch (error) {
+    emitFailure(options.json, "invalid_api_url", safeMessage(error));
+    return null;
+  }
+  if (options.apiKey !== void 0) {
+    if (!isHostedApiKey(options.apiKey)) {
+      emitFailure(options.json, "invalid_team_data_key", "Team data API key is invalid.");
+      return null;
+    }
+    if (options.team) {
+      emitFailure(
+        options.json,
+        "team_selector_with_api_key",
+        "A Team data key already selects its Team; omit --team."
+      );
+      return null;
+    }
+    return { apiOrigin, credential: options.apiKey, team: null };
+  }
+  if (!allowsStoredAccountSession()) {
+    emitFailure(
+      options.json,
+      "api_key_required",
+      "CI requires TILEFLOW_API_KEY or --api-key. Saved personal logins are not used in CI."
+    );
+    return null;
+  }
+  let config;
+  try {
+    config = await dependencies.loadAuthConfig();
+  } catch (error) {
+    emitFailure(options.json, "auth_state_unavailable", safeMessage(error));
+    return null;
+  }
+  const selected = resolveAccountSession(config, options.apiUrl ?? dependencies.defaultApiUrl);
+  if (selected.kind !== "selected") {
+    emitFailure(
+      options.json,
+      `account_session_${selected.kind}`,
+      selected.kind === "expired" ? "Account session expired. Run tileflow login." : "Run tileflow login."
+    );
+    return null;
+  }
+  const discovered = await listAccountTeams(selected.session);
+  if (!discovered.ok) {
+    emitFailure(options.json, "team_discovery_failed", discovered.error);
+    return null;
+  }
+  const requested = options.team ? /^@([A-Za-z0-9][A-Za-z0-9._-]{0,127})$/u.exec(options.team) : null;
+  if (options.team && !requested) {
+    emitFailure(options.json, "invalid_team", "Team must use @team syntax.");
+    return null;
+  }
+  const team = requested ? discovered.teams.find(({ slug }) => slug === requested[1]) : discovered.teams.length === 1 ? discovered.teams[0] : null;
+  if (!team) {
+    const options_ = discovered.teams.map(({ slug }) => `@${slug}`);
+    emitFailure(
+      options.json,
+      options_.length > 1 ? "team_ambiguous" : "team_not_found",
+      options_.length > 1 ? `Choose one Team with --team: ${options_.join(", ")}.` : "No matching Team is available.",
+      { options: options_ }
+    );
+    return null;
+  }
+  const capability = await requestTeamCapability(selected.session, `@${team.slug}`, scopes);
+  if (!capability.ok || capability.team.id !== team.id) {
+    emitFailure(
+      options.json,
+      "team_capability_failed",
+      capability.ok ? "Team capability response was invalid." : capability.error
+    );
+    return null;
+  }
+  let current = capability;
+  let renewal;
+  const getCredential = async () => {
+    if (Date.parse(current.expiresAt) > Date.now() + 3e4) return current.capability;
+    renewal ??= requestTeamCapability(selected.session, `@${team.slug}`, scopes).then((next) => {
+      if (!next.ok || next.team.id !== team.id || Date.parse(next.expiresAt) <= Date.now() + 3e4) {
+        throw new Error("Team authorization could not be renewed. Run tileflow login.");
+      }
+      current = next;
+    }).finally(() => {
+      renewal = void 0;
+    });
+    await renewal;
+    return current.capability;
+  };
+  return {
+    apiOrigin: selected.session.apiOrigin,
+    credential: capability.capability,
+    getCredential,
+    team
+  };
+}
+async function authorizedTeamRequest(authority, path, method, init = {}) {
+  const credential = await authority.getCredential?.() ?? authority.credential;
+  return requestHostedJson(authority.apiOrigin, path, {
+    ...init.body === void 0 ? {} : { body: init.body },
+    headers: { Authorization: `Bearer ${credential}`, ...init.headers },
+    method
+  });
+}
+function emitJson(value) {
+  process.stdout.write(`${serializeCanonicalJson(value)}
+`);
+}
+function emitFailure(json, code, message, context = {}) {
+  if (json) {
+    process.stderr.write(
+      `${serializeCanonicalJson({ error: { code, ...context, message }, ok: false, schemaVersion: 1 })}
+`
+    );
+  } else {
+    console.error(`${pc2.red("Error:")} ${message}`);
+  }
+  process.exitCode = 1;
+}
+function safeMessage(error) {
+  return error instanceof Error ? error.message : "Team command failed.";
+}
+
+// src/tileset-upload.ts
+import { createHash } from "crypto";
+import { open as open2, stat } from "fs/promises";
+import { z as z3 } from "zod";
+import { serializeCanonicalJson as serializeCanonicalJson2 } from "@tileflow/core";
+var teamTilesetPartSize = 16777216;
+var maximumTeamTilesetBytes = 4e9;
+var authorizationBatchSize = 16;
+var uploadConcurrency = 4;
+var maximumPartAttempts = 4;
+var maximumControlAttempts = 4;
+var maximumInitiatingWaitMs = 2 * 60 * 1e3;
+var partTransferTimeoutMs = 10 * 60 * 1e3;
+var authorizationClockSkewMs = 3e4;
+var minimumPartAuthorizationLifetimeMs = partTransferTimeoutMs + authorizationClockSkewMs;
+var TeamTilesetUploadError = class extends Error {
+  code;
+  details;
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = "TeamTilesetUploadError";
+    this.code = code;
+    this.details = details;
+  }
+};
+function createTeamTilesetPartLayout(byteCount) {
+  if (!Number.isSafeInteger(byteCount) || byteCount < 1 || byteCount > maximumTeamTilesetBytes) {
+    throw new TeamTilesetUploadError(
+      "TF_TILESET_VERSION_TOO_LARGE",
+      "PMTiles archive exceeds the 4,000,000,000-byte platform maximum.",
+      {
+        actualBytes: Number.isSafeInteger(byteCount) && byteCount >= 0 ? byteCount : 0,
+        limitBytes: maximumTeamTilesetBytes
+      }
+    );
+  }
+  return Object.freeze(
+    Array.from({ length: Math.ceil(byteCount / teamTilesetPartSize) }, (_, index) => {
+      const position = index * teamTilesetPartSize;
+      return Object.freeze({
+        byteCount: Math.min(teamTilesetPartSize, byteCount - position),
+        partNumber: index + 1,
+        position
+      });
+    })
+  );
+}
+async function inspectNodeTeamTilesetArchive(path) {
+  let value;
+  try {
+    value = await stat(path, { bigint: true });
+  } catch {
+    throw new TeamTilesetUploadError(
+      "TF_TILESET_ARCHIVE_INVALID",
+      "PMTiles archive is unavailable."
+    );
+  }
+  if (!value.isFile()) {
+    throw new TeamTilesetUploadError(
+      "TF_TILESET_ARCHIVE_INVALID",
+      "PMTiles archive must be a file."
+    );
+  }
+  return checkedIdentity(value.dev, value.ino, value.mtimeNs, value.size);
+}
+async function openNodeTeamTilesetArchive(path, expectedIdentity) {
+  const handle = await open2(path, "r");
+  const identity = async () => {
+    let pathStat;
+    let handleStat;
+    try {
+      [pathStat, handleStat] = await Promise.all([
+        stat(path, { bigint: true }),
+        handle.stat({ bigint: true })
+      ]);
+    } catch {
+      throw localFileChanged();
+    }
+    if (!pathStat.isFile() || !handleStat.isFile()) throw localFileChanged();
+    const pathIdentity = checkedIdentity(
+      pathStat.dev,
+      pathStat.ino,
+      pathStat.mtimeNs,
+      pathStat.size
+    );
+    const handleIdentity = checkedIdentity(
+      handleStat.dev,
+      handleStat.ino,
+      handleStat.mtimeNs,
+      handleStat.size
+    );
+    assertFileIdentity(pathIdentity, handleIdentity);
+    return pathIdentity;
+  };
+  try {
+    assertFileIdentity(expectedIdentity, await identity());
+  } catch (error) {
+    await handle.close();
+    throw error;
+  }
+  const readInto = async (position, target) => {
+    let offset = 0;
+    while (offset < target.byteLength) {
+      const result = await handle.read(
+        target,
+        offset,
+        target.byteLength - offset,
+        position + offset
+      );
+      if (result.bytesRead === 0) throw localFileChanged();
+      offset += result.bytesRead;
+    }
+    return offset;
+  };
+  return {
+    close: () => handle.close(),
+    identity,
+    async read(position, byteCount) {
+      const bytes = Buffer.allocUnsafe(byteCount);
+      await readInto(position, bytes);
+      return bytes;
+    },
+    readInto
+  };
+}
+async function prepareTeamTilesetUpload(file) {
+  const identity = await file.identity();
+  const layout = createTeamTilesetPartLayout(identity.size);
+  const parts = [];
+  const reusable = file.readInto ? Buffer.allocUnsafe(Math.min(identity.size, teamTilesetPartSize)) : void 0;
+  for (const part of layout) {
+    const bytes = reusable ? reusable.subarray(0, part.byteCount) : await file.read(part.position, part.byteCount);
+    if (reusable && await file.readInto(part.position, bytes) !== part.byteCount) {
+      throw localFileChanged();
+    }
+    if (bytes.byteLength !== part.byteCount) throw localFileChanged();
+    parts.push(
+      Object.freeze({
+        byteCount: part.byteCount,
+        md5Base64: createHash("md5").update(bytes).digest("base64"),
+        partNumber: part.partNumber,
+        sha256Base64: createHash("sha256").update(bytes).digest("base64")
+      })
+    );
+  }
+  assertFileIdentity(identity, await file.identity());
+  const contentIdentity = {
+    algorithm: "sha256-fixed-parts-v1",
+    byteCount: identity.size,
+    partSize: teamTilesetPartSize,
+    parts: parts.map(({ byteCount, partNumber, sha256Base64 }) => ({
+      byteCount,
+      partNumber,
+      sha256Base64
+    }))
+  };
+  return Object.freeze({
+    byteCount: identity.size,
+    contentHash: createHash("sha256").update(serializeCanonicalJson2(contentIdentity)).digest("hex"),
+    contentHashAlgorithm: "sha256-fixed-parts-v1",
+    identity,
+    partSize: teamTilesetPartSize,
+    parts: Object.freeze(parts),
+    schemaVersion: 1
+  });
+}
+function createTeamTilesetUploadIdempotencyKey(tilesetId, upload) {
+  if (!/^tls_[A-Za-z0-9_-]{16,76}$/u.test(tilesetId)) {
+    throw new TeamTilesetUploadError(
+      "TF_TILESET_NOT_FOUND",
+      "Tileset registration returned an invalid ID."
+    );
+  }
+  return createHash("sha256").update(
+    serializeCanonicalJson2({
+      byteCount: upload.byteCount,
+      contentHash: upload.contentHash,
+      contentHashAlgorithm: upload.contentHashAlgorithm,
+      tilesetId
+    })
+  ).digest("hex");
+}
+async function publishPreparedTeamTilesetUpload(input) {
+  assertFileIdentity(input.upload.identity, await input.file.identity());
+  const beginInput = {
+    byteCount: input.upload.byteCount,
+    contentHash: input.upload.contentHash,
+    contentHashAlgorithm: input.upload.contentHashAlgorithm,
+    idempotencyKey: createTeamTilesetUploadIdempotencyKey(input.tilesetId, input.upload),
+    parts: input.upload.parts,
+    partSize: input.upload.partSize,
+    schemaVersion: 1
+  };
+  const begun = await input.transport.begin(beginInput);
+  assertSessionMatches(begun, input.upload);
+  const changed = begun.state !== "published";
+  if (begun.state === "published") return publicationResult(begun, input.upload, changed);
+  let current = await input.transport.status(begun.uploadId);
+  assertSessionMatches(current, input.upload, true);
+  assertUsableSession(current);
+  let initiatingWaitMs = 0;
+  for (let attempt = 1; current.state === "initiating"; attempt += 1) {
+    const delay = Math.min(
+      2e3,
+      250 * 2 ** Math.min(attempt - 1, 3),
+      maximumInitiatingWaitMs - initiatingWaitMs
+    );
+    if (delay <= 0) {
+      throw new TeamTilesetUploadError(
+        "TF_TILESET_UPLOAD_UNAVAILABLE",
+        "Tileset upload initialization did not converge within two minutes."
+      );
+    }
+    await (input.sleep ?? defaultSleep)(delay);
+    initiatingWaitMs += delay;
+    current = await input.transport.status(current.uploadId);
+    assertSessionMatches(current, input.upload, true);
+    assertUsableSession(current);
+  }
+  if (current.state === "uploading") {
+    const uploading = current;
+    const missingParts = input.upload.parts.filter(
+      (part) => !uploading.parts.find((candidate) => candidate.partNumber === part.partNumber)?.uploaded
+    );
+    await uploadMissingParts({ ...input, missingParts, uploadId: uploading.uploadId });
+    assertFileIdentity(input.upload.identity, await input.file.identity());
+    current = await input.transport.complete(uploading.uploadId);
+    assertSessionMatches(current, input.upload);
+    assertUsableSession(current);
+  }
+  while (current.state !== "published") {
+    if (!["publishing", "ready_to_publish", "validating"].includes(current.state)) {
+      throw new TeamTilesetUploadError(
+        "TF_TILESET_UPLOAD_UNAVAILABLE",
+        "Tileset upload cannot continue from its current state."
+      );
+    }
+    input.onProgress?.({
+      completedParts: input.upload.parts.length,
+      phase: "validating",
+      totalParts: input.upload.parts.length
+    });
+    await (input.sleep ?? defaultSleep)(2e3);
+    current = await input.transport.status(current.uploadId);
+    assertSessionMatches(current, input.upload, true);
+    assertUsableSession(current);
+  }
+  return publicationResult(current, input.upload, changed);
+}
+function createHostedTeamTilesetUploadTransport(input) {
+  const basePath = `/v1/tilesets/${encodeURIComponent(input.tilesetId)}/uploads`;
+  const control = async (path, init) => {
+    for (let attempt = 1; attempt <= maximumControlAttempts; attempt += 1) {
+      let credential;
+      try {
+        credential = await input.getCredential?.() ?? input.credential;
+      } catch {
+        throw new TeamTilesetUploadError(
+          "TF_TILESET_UPLOAD_UNAVAILABLE",
+          "Team authorization could not be renewed. Run tileflow login and retry the upload."
+        );
+      }
+      let response;
+      try {
+        response = await requestHostedJson(
+          input.apiOrigin,
+          path,
+          {
+            ...init,
+            headers: {
+              Authorization: `Bearer ${credential}`,
+              ...init.body ? { "Content-Type": "application/json" } : {},
+              ...init.headers
+            }
+          },
+          { fetch: input.fetch }
+        );
+      } catch {
+        if (attempt === maximumControlAttempts) {
+          throw new TeamTilesetUploadError(
+            "TF_TILESET_UPLOAD_UNAVAILABLE",
+            "Tileset upload control request did not complete."
+          );
+        }
+      }
+      if (response?.ok) return response.body;
+      if (response && (asRecord2(response.body).code === "TF_TILESET_UPLOAD_DISABLED" || !isRetryableStatus(response.status))) {
+        throw responseError(response);
+      }
+      if (attempt === maximumControlAttempts) {
+        if (response) throw responseError(response);
+        break;
+      }
+      await (input.sleep ?? defaultSleep)(Math.min(2e3, 250 * 2 ** (attempt - 1)));
+    }
+    throw new TeamTilesetUploadError(
+      "TF_TILESET_UPLOAD_UNAVAILABLE",
+      "Tileset upload control request did not complete."
+    );
+  };
+  return {
+    async authorize(uploadId, partNumbers) {
+      const body = await control(
+        `${basePath}/${encodeURIComponent(uploadId)}/part-authorizations`,
+        {
+          body: JSON.stringify({ partNumbers, schemaVersion: 1 }),
+          method: "POST"
+        }
+      );
+      return authorizationResponseSchema.parse(body).authorizations;
+    },
+    async begin(body) {
+      return parseUploadSession(
+        await control(basePath, { body: JSON.stringify(body), method: "POST" })
+      );
+    },
+    async complete(uploadId) {
+      return parseUploadSession(
+        await control(`${basePath}/${encodeURIComponent(uploadId)}/complete`, {
+          body: JSON.stringify({ schemaVersion: 1 }),
+          method: "POST"
+        })
+      );
+    },
+    async putPart(authorization, bytes) {
+      const controller = new AbortController();
+      try {
+        const body = new ReadableStream({
+          start(controller2) {
+            controller2.enqueue(bytes);
+            controller2.close();
+          }
+        });
+        const response = await (input.fetch ?? globalThis.fetch)(authorization.url, {
+          body,
+          duplex: "half",
+          headers: authorization.headers,
+          method: "PUT",
+          redirect: "error",
+          signal: AbortSignal.any([controller.signal, AbortSignal.timeout(partTransferTimeoutMs)])
+        });
+        const etag = response.headers.get("etag");
+        await response.body?.cancel().catch(() => void 0);
+        return { etag, status: response.status };
+      } catch {
+        throw new Error("Direct part transfer failed.");
+      } finally {
+        controller.abort();
+      }
+    },
+    async recordPart(uploadId, body) {
+      partReceiptResponseSchema.parse(
+        await control(`${basePath}/${encodeURIComponent(uploadId)}/parts`, {
+          body: JSON.stringify(body),
+          method: "POST"
+        })
+      );
+    },
+    async status(uploadId) {
+      return parseUploadSession(
+        await control(`${basePath}/${encodeURIComponent(uploadId)}`, { method: "GET" })
+      );
+    }
+  };
+}
+async function uploadMissingParts(input) {
+  let completedParts = input.upload.parts.length - input.missingParts.length;
+  const transferBufferBytes = Math.max(0, ...input.missingParts.map((part) => part.byteCount));
+  const transferBuffers = input.file.readInto ? Array.from(
+    { length: Math.min(uploadConcurrency, input.missingParts.length) },
+    () => Buffer.allocUnsafe(transferBufferBytes)
+  ) : [];
+  for (let offset = 0; offset < input.missingParts.length; offset += authorizationBatchSize) {
+    const authorizationParts = input.missingParts.slice(offset, offset + authorizationBatchSize);
+    const initial = indexAuthorizations(
+      await input.transport.authorize(
+        input.uploadId,
+        authorizationParts.map(({ partNumber }) => partNumber)
+      ),
+      authorizationParts
+    );
+    for (let groupOffset = 0; groupOffset < authorizationParts.length; groupOffset += uploadConcurrency) {
+      assertFileIdentity(input.upload.identity, await input.file.identity());
+      const group = authorizationParts.slice(groupOffset, groupOffset + uploadConcurrency);
+      const settled = await Promise.allSettled(
+        group.map(async (part, index) => {
+          const position = (part.partNumber - 1) * teamTilesetPartSize;
+          const reusable = transferBuffers[index];
+          const bytes = reusable ? reusable.subarray(0, part.byteCount) : await input.file.read(position, part.byteCount);
+          if (reusable && await input.file.readInto(position, bytes) !== part.byteCount) {
+            throw localFileChanged();
+          }
+          if (bytes.byteLength !== part.byteCount) throw localFileChanged();
+          await uploadPartWithRetry({
+            ...input,
+            initialAuthorization: initial.get(part.partNumber),
+            part,
+            bytes
+          });
+        })
+      );
+      const failed = settled.find(
+        (result) => result.status === "rejected"
+      );
+      if (failed) throw failed.reason;
+      completedParts += group.length;
+      input.onProgress?.({
+        completedParts,
+        phase: "uploading",
+        totalParts: input.upload.parts.length
+      });
+    }
+  }
+}
+async function uploadPartWithRetry(input) {
+  let authorization = input.initialAuthorization;
+  for (let attempt = 1; attempt <= maximumPartAttempts; attempt += 1) {
+    if (!authorizationCoversTransfer(authorization, input.now?.() ?? Date.now())) {
+      const refreshed2 = await input.transport.authorize(input.uploadId, [input.part.partNumber]);
+      authorization = indexAuthorizations(refreshed2, [input.part]).get(input.part.partNumber);
+      if (!authorizationCoversTransfer(authorization, input.now?.() ?? Date.now())) {
+        throw invalidRemoteResponse();
+      }
+    }
+    assertAuthorizationMatches(authorization, input.part);
+    let result;
+    try {
+      result = await input.transport.putPart(authorization, input.bytes);
+    } catch {
+      result = { etag: null, status: 503 };
+    }
+    if (result.status >= 200 && result.status < 300) {
+      const etag = normalizePartEtag(result.etag, input.part.md5Base64);
+      await input.transport.recordPart(input.uploadId, {
+        etag,
+        partNumber: input.part.partNumber
+      });
+      return;
+    }
+    if ((result.status === 401 || result.status === 403) && !authorizationCoversTransfer(authorization, input.now?.() ?? Date.now()) && attempt < maximumPartAttempts) {
+      const refreshed2 = await input.transport.authorize(input.uploadId, [input.part.partNumber]);
+      authorization = indexAuthorizations(refreshed2, [input.part]).get(input.part.partNumber);
+      continue;
+    }
+    if (!isRetryableStatus(result.status)) {
+      throw new TeamTilesetUploadError(
+        result.status === 401 || result.status === 403 ? "TF_TILESET_UPLOAD_AUTHORIZATION_FAILED" : "TF_TILESET_UPLOAD_PART_INVALID",
+        "Direct part transfer was rejected."
+      );
+    }
+    if (attempt === maximumPartAttempts) break;
+    await (input.sleep ?? defaultSleep)(Math.min(2e3, 250 * 2 ** (attempt - 1)));
+    const refreshed = await input.transport.authorize(input.uploadId, [input.part.partNumber]);
+    authorization = indexAuthorizations(refreshed, [input.part]).get(input.part.partNumber);
+  }
+  throw new TeamTilesetUploadError(
+    "TF_TILESET_UPLOAD_UNAVAILABLE",
+    "Direct part transfer did not complete after bounded retries."
+  );
+}
+function authorizationCoversTransfer(authorization, now) {
+  return Date.parse(authorization.expiresAt) - now >= minimumPartAuthorizationLifetimeMs;
+}
+function isRetryableStatus(status) {
+  return status === 408 || status === 429 || status >= 500;
+}
+function indexAuthorizations(authorizations, parts) {
+  const expected = new Map(parts.map((part) => [part.partNumber, part]));
+  const indexed = /* @__PURE__ */ new Map();
+  for (const authorization of authorizations) {
+    const part = expected.get(authorization.partNumber);
+    if (!part || indexed.has(authorization.partNumber)) {
+      throw invalidRemoteResponse();
+    }
+    assertAuthorizationMatches(authorization, part);
+    indexed.set(authorization.partNumber, authorization);
+  }
+  if (indexed.size !== expected.size) throw invalidRemoteResponse();
+  return indexed;
+}
+function assertAuthorizationMatches(authorization, part) {
+  if (authorization.partNumber !== part.partNumber || authorization.method !== "PUT" || authorization.headers["Content-Length"] !== String(part.byteCount) || authorization.headers["Content-MD5"] !== part.md5Base64) {
+    throw invalidRemoteResponse();
+  }
+}
+function normalizePartEtag(value, md5Base64) {
+  if (!value || !/^(?:[0-9a-f]{32}|"[0-9a-f]{32}")$/u.test(value)) {
+    throw new TeamTilesetUploadError(
+      "TF_TILESET_UPLOAD_PART_INVALID",
+      "Direct part transfer returned an invalid ETag."
+    );
+  }
+  const normalized = value.replaceAll('"', "");
+  if (normalized !== Buffer.from(md5Base64, "base64").toString("hex")) {
+    throw new TeamTilesetUploadError(
+      "TF_TILESET_UPLOAD_PART_INVALID",
+      "Direct part transfer returned a conflicting ETag."
+    );
+  }
+  return normalized;
+}
+function assertSessionMatches(session, upload, requireParts = false) {
+  if (session.byteCount !== upload.byteCount || session.contentHash !== upload.contentHash || session.contentHashAlgorithm !== upload.contentHashAlgorithm) {
+    throw invalidRemoteResponse();
+  }
+  if (session.state === "published") return;
+  if (session.partCount !== upload.parts.length || session.partSize !== upload.partSize || requireParts && session.parts.length !== upload.parts.length || session.parts.some((part, index) => {
+    const expected = upload.parts[index];
+    return !expected || part.partNumber !== expected.partNumber || part.byteCount !== expected.byteCount;
+  })) {
+    throw invalidRemoteResponse();
+  }
+}
+function assertUsableSession(session) {
+  if (session.state === "published") return;
+  if (session.failure) {
+    throw new TeamTilesetUploadError(session.failure.code, failureMessage(session.failure.code));
+  }
+  if (["aborted", "aborting", "expired", "expiring", "rejected", "rejecting"].includes(session.state)) {
+    throw new TeamTilesetUploadError(
+      "TF_TILESET_UPLOAD_UNAVAILABLE",
+      "Tileset upload is no longer resumable."
+    );
+  }
+}
+function publicationResult(session, upload, changed) {
+  return Object.freeze({
+    byteCount: upload.byteCount,
+    changed,
+    contentHash: upload.contentHash,
+    contentHashAlgorithm: upload.contentHashAlgorithm,
+    state: "published",
+    version: session.publishedVersion,
+    versionId: session.versionId
+  });
+}
+function assertFileIdentity(expected, actual) {
+  const inodeChanged = expected.inode !== 0n && actual.inode !== 0n && (expected.inode !== actual.inode || expected.device !== actual.device);
+  if (inodeChanged || expected.size !== actual.size || expected.mtimeNanoseconds !== actual.mtimeNanoseconds) {
+    throw localFileChanged();
+  }
+}
+function checkedIdentity(device, inode, mtimeNanoseconds, size) {
+  const numericSize = Number(size);
+  if (numericSize === 0) {
+    throw new TeamTilesetUploadError("TF_TILESET_ARCHIVE_EMPTY", "PMTiles archive is empty.");
+  }
+  if (numericSize > maximumTeamTilesetBytes) {
+    throw new TeamTilesetUploadError(
+      "TF_TILESET_VERSION_TOO_LARGE",
+      "PMTiles archive exceeds the 4,000,000,000-byte platform maximum.",
+      { actualBytes: numericSize, limitBytes: maximumTeamTilesetBytes }
+    );
+  }
+  return Object.freeze({ device, inode, mtimeNanoseconds, size: numericSize });
+}
+function localFileChanged() {
+  return new TeamTilesetUploadError(
+    "TF_TILESET_LOCAL_FILE_CHANGED",
+    "PMTiles archive changed during publication."
+  );
+}
+function invalidRemoteResponse() {
+  return new TeamTilesetUploadError(
+    "TF_TILESET_UPLOAD_UNAVAILABLE",
+    "Tileset upload returned an invalid response."
+  );
+}
+function failureMessage(code) {
+  if (code === "TF_TILESET_UPLOAD_DISABLED") return "New tileset uploads are disabled.";
+  if (code === "TF_TILESET_SCHEMA_INCOMPATIBLE") {
+    return "Tileset schema is incompatible with retained Map deployments.";
+  }
+  if (code === "TF_TILESET_UPLOAD_CHECKSUM_MISMATCH") {
+    return "Tileset upload checksum validation failed.";
+  }
+  if (code === "TF_TILESET_UPLOAD_EXPIRED") return "Tileset upload expired.";
+  return "Tileset upload failed.";
+}
+function responseError(response) {
+  const body = asRecord2(response.body);
+  const code = typeof body.code === "string" && /^TF_[A-Z0-9_]{1,96}$/u.test(body.code) ? body.code : "TF_TILESET_UPLOAD_UNAVAILABLE";
+  const details = numericDetails(body.details);
+  return new TeamTilesetUploadError(code, failureMessage(code), details);
+}
+function numericDetails(value) {
+  const source = asRecord2(value);
+  const details = {};
+  for (const key of ["actualBytes", "limitBytes"]) {
+    const candidate = source[key];
+    if (Number.isSafeInteger(candidate) && candidate >= 0) {
+      details[key] = candidate;
+    }
+  }
+  return Object.freeze(details);
+}
+function parseUploadSession(value) {
+  return uploadSessionSchema.parse(value);
+}
+function asRecord2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function defaultSleep(milliseconds) {
+  return new Promise((resolve2) => setTimeout(resolve2, milliseconds));
+}
+var identifierSchema = z3.string().min(20).max(80).regex(/^[A-Za-z0-9_-]+$/u);
+var uploadPartStatusSchema = z3.object({
+  byteCount: z3.number().int().min(1).max(teamTilesetPartSize),
+  partNumber: z3.number().int().min(1).max(239),
+  uploaded: z3.boolean(),
+  validationState: z3.enum(["mismatch", "pending", "processing", "valid"])
+}).strict();
+var publishedVersionSchema = z3.object({
+  byteCount: z3.number().int().min(1).max(maximumTeamTilesetBytes),
+  contentHash: z3.string().regex(/^[0-9a-f]{64}$/u),
+  contentHashAlgorithm: z3.literal("sha256-fixed-parts-v1"),
+  publishedVersion: z3.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  schemaVersion: z3.literal(1),
+  state: z3.literal("published"),
+  versionId: identifierSchema.regex(/^tsv_[A-Za-z0-9_-]+$/u)
+}).strict();
+var uploadControlSchema = z3.object({
+  byteCount: z3.number().int().min(1).max(maximumTeamTilesetBytes),
+  contentHash: z3.string().regex(/^[0-9a-f]{64}$/u),
+  contentHashAlgorithm: z3.literal("sha256-fixed-parts-v1"),
+  expiresAt: z3.iso.datetime({ offset: true }),
+  failure: z3.object({ code: z3.string().regex(/^TF_[A-Z0-9_]{1,96}$/u) }).strict().nullable(),
+  partCount: z3.number().int().min(1).max(239),
+  parts: z3.array(uploadPartStatusSchema).max(239),
+  partSize: z3.literal(teamTilesetPartSize),
+  publishedVersion: z3.null(),
+  schemaVersion: z3.literal(1),
+  state: z3.enum([
+    "aborted",
+    "aborting",
+    "expired",
+    "expiring",
+    "initiating",
+    "publishing",
+    "ready_to_publish",
+    "rejected",
+    "rejecting",
+    "uploading",
+    "validating"
+  ]),
+  uploadId: z3.string().min(20).max(80).regex(/^tsu_[A-Za-z0-9_-]+$/u),
+  versionId: z3.null()
+}).strict();
+var uploadSessionSchema = z3.union([publishedVersionSchema, uploadControlSchema]);
+var authorizationSchema = z3.object({
+  expiresAt: z3.iso.datetime({ offset: true }),
+  headers: z3.object({
+    "Content-Length": z3.string().regex(/^[1-9][0-9]{0,9}$/u),
+    "Content-MD5": z3.string().regex(/^[A-Za-z0-9+/]{22}==$/u)
+  }).strict(),
+  method: z3.literal("PUT"),
+  partNumber: z3.number().int().min(1).max(239),
+  url: z3.url().max(8192).refine((value) => {
+    const url = new URL(value);
+    return url.protocol === "https:" && !url.username && !url.password && !url.hash;
+  })
+}).strict();
+var authorizationResponseSchema = z3.object({
+  authorizations: z3.array(authorizationSchema).min(1).max(16),
+  schemaVersion: z3.literal(1)
+}).strict();
+var partReceiptResponseSchema = z3.object({
+  changed: z3.boolean(),
+  etag: z3.string().regex(/^[0-9a-f]{32}$/u),
+  partNumber: z3.number().int().min(1).max(239),
+  schemaVersion: z3.literal(1)
+}).strict();
+
+// src/tileset-command.ts
+function registerTilesetInspectCommand(parent, name = "inspect") {
+  parent.command(name).description("Inspect one local PMTiles archive deterministically").argument("<archive>", "repository-local PMTiles archive").option("--json", "print deterministic inspection-schema-version-1 JSON").option("--no-sample", "read authoritative header and metadata without bounded MVT sampling").option(
+    "--include-values <fields>",
+    "include bounded observed values for comma-separated field names (requires --json)"
+  ).action(
+    async (archive, options) => {
+      try {
+        if (options.includeValues && !options.json) {
+          throw inspectionOptionError("--include-values requires --json.");
+        }
+        const inspection = await inspectTileflowPmtiles(archive, {
+          includeValues: parseIncludedValueFields(options.includeValues),
+          sample: options.sample
+        });
+        if (options.json) {
+          process.stdout.write(`${serializeCanonicalJson3(inspection)}
+`);
+          return;
+        }
+        console.log(`${pc3.green("\u2713")} PMTiles archive is valid.`);
+        console.log(`  Type: ${inspection.contract.tileType}`);
+        console.log(`  Zooms: ${inspection.contract.minzoom}-${inspection.contract.maxzoom}`);
+        console.log(`  Source layers: ${inspection.contract.sourceLayers.length}`);
+        if (inspection.observation) {
+          console.log(
+            `  Sample: ${inspection.observation.featuresRead} features in ${inspection.observation.tilesRead} tiles`
+          );
+        }
+        for (const warning of inspection.warnings) {
+          console.log(`${pc3.yellow("!")} ${warning.message}`);
+        }
+      } catch (error) {
+        const record = asRecord3(error);
+        const code = typeof record.code === "string" ? record.code : "TF_TILESET_INSPECTION_FAILED";
+        const path = typeof record.path === "string" ? record.path : "archive";
+        const message = error instanceof Error ? error.message : "Tileset inspection failed.";
+        if (options.json) {
+          process.stderr.write(
+            `${serializeCanonicalJson3({ error: { code, message, path }, ok: false, schemaVersion: 1 })}
+`
+          );
+        } else {
+          console.error(`${pc3.red("Error:")} ${message}`);
+        }
+        process.exitCode = 1;
+      }
+    }
+  );
+}
+function registerTilesetCommands(program, dependencies) {
+  const tileset = program.command("tileset").description("Inspect and manage geospatial tilesets");
+  registerTilesetInspectCommand(tileset);
+  tileset.command("publish").description("Register and publish one PMTiles archive to a Team").argument("<archive>", "repository-local PMTiles archive").requiredOption("--id <id>", "Team-local logical tileset ID").option("--name <name>", "display name").option("--attribution <text>", "data attribution").option("--team <team>", "target Team as @team").addOption(hostedApiUrlOption()).addOption(hostedApiKeyOption("Team data API key")).option("--json", "print deterministic schema-version-2 JSON").action(
+    async (archive, options) => {
+      let uploadFile = null;
+      try {
+        if (!isTilesetId(options.id)) {
+          return emitFailure(options.json, "invalid_tileset_id", "Tileset ID is invalid.");
+        }
+        const initialIdentity = await inspectNodeTeamTilesetArchive(archive);
+        await inspectTileflowPmtiles(archive, { sample: false });
+        uploadFile = await openNodeTeamTilesetArchive(archive, initialIdentity);
+        const prepared = await prepareTeamTilesetUpload(uploadFile);
+        const authority = await resolveTeamAuthority(options, ["tilesets:write"], dependencies);
+        if (!authority) return;
+        const registration = await authorizedTeamRequest(authority, "/v1/tilesets", "POST", {
+          body: JSON.stringify({
+            ...options.attribution ? { attribution: options.attribution } : {},
+            format: "pmtiles",
+            name: options.name?.trim() || options.id,
+            slug: options.id
+          }),
+          headers: {
+            "Content-Type": "application/json"
+          }
+        });
+        const registered = asRecord3(registration.body);
+        const resourceId = String(registered.tilesetId ?? "");
+        if (!registration.ok || !/^tls_[A-Za-z0-9_-]{16,76}$/u.test(resourceId)) {
+          return emitFailure(
+            options.json,
+            `http_${registration.status}`,
+            `Tileset registration failed (${registration.status}).`
+          );
+        }
+        let reportedParts = 0;
+        let reportedValidation = false;
+        const publication = await publishPreparedTeamTilesetUpload({
+          file: uploadFile,
+          onProgress: options.json ? void 0 : ({ completedParts, phase, totalParts }) => {
+            if (phase === "validating") {
+              if (!reportedValidation) {
+                process.stderr.write("Validating uploaded bytes.\n");
+                reportedValidation = true;
+              }
+              return;
+            }
+            if (completedParts === totalParts || completedParts - reportedParts >= 16) {
+              process.stderr.write(`Uploaded ${completedParts}/${totalParts} parts.
+`);
+              reportedParts = completedParts;
+            }
+          },
+          tilesetId: resourceId,
+          transport: createHostedTeamTilesetUploadTransport({
+            apiOrigin: authority.apiOrigin,
+            credential: authority.credential,
+            getCredential: authority.getCredential,
+            tilesetId: resourceId
+          }),
+          upload: prepared
+        });
+        const document = {
+          command: "tileset publish",
+          publication: publication.changed ? "changed" : "unchanged",
+          schemaVersion: 2,
+          team: authority.team ? { id: authority.team.id, slug: authority.team.slug } : null,
+          tileset: {
+            byteCount: publication.byteCount,
+            contentHash: publication.contentHash,
+            contentHashAlgorithm: publication.contentHashAlgorithm,
+            logicalId: options.id,
+            state: publication.state,
+            tilesetId: resourceId,
+            version: { id: publication.versionId, number: publication.version }
+          }
+        };
+        if (options.json) return emitJson(document);
+        console.log(
+          `${pc3.green("\u2713")} ${publication.changed ? "Published" : "Unchanged"} ${pc3.bold(options.id)} in ${authority.team ? `@${authority.team.slug}` : "the Team bound to the data key"}.`
+        );
+      } catch (error) {
+        if (error instanceof TeamTilesetUploadError) {
+          emitFailure(options.json, error.code, error.message, error.details);
+        } else {
+          emitFailure(options.json, "tileset_publish_failed", "Tileset publication failed.");
+        }
+      } finally {
+        await uploadFile?.close().catch(() => void 0);
+      }
+    }
+  );
+  tileset.command("list").description("List tilesets owned by one Team").option("--team <team>", "target Team as @team").addOption(hostedApiUrlOption()).addOption(hostedApiKeyOption("Team data API key")).option("--json", "print deterministic schema-version-1 JSON").action(async (options) => {
+    try {
+      const authority = await resolveTeamAuthority(options, ["tilesets:read"], dependencies);
+      if (!authority) return;
+      const items = await fetchAllTeamTilesets(authority);
+      const document = { command: "tileset list", schemaVersion: 1, tilesets: items };
+      if (options.json) return emitJson(document);
+      if (items.length === 0) return console.log(pc3.gray("No Team tilesets."));
+      for (const item of items) {
+        console.log(`  ${pc3.bold(item.logicalName)} ${pc3.gray(item.status)}`);
+      }
+    } catch {
+      emitFailure(options.json, "tileset_list_failed", "Tileset list failed.");
+    }
+  });
+  tileset.command("status").description("Show one Team tileset").argument("<id>", "Team-local logical ID or opaque resource ID").option("--team <team>", "target Team as @team").addOption(hostedApiUrlOption()).addOption(hostedApiKeyOption("Team data API key")).option("--json", "print deterministic schema-version-1 JSON").action(async (id, options) => {
+    try {
+      if (!isTilesetId(id))
+        return emitFailure(options.json, "invalid_tileset_id", "Tileset ID is invalid.");
+      const authority = await resolveTeamAuthority(options, ["tilesets:read"], dependencies);
+      if (!authority) return;
+      const response = await authorizedTeamRequest(
+        authority,
+        `/v1/tilesets/${encodeURIComponent(id)}`,
+        "GET"
+      );
+      if (!response.ok) {
+        return emitFailure(
+          options.json,
+          `http_${response.status}`,
+          `Tileset status failed (${response.status}).`
+        );
+      }
+      const parsed = tilesetDetailResponseSchema.parse(response.body);
+      const document = { command: "tileset status", schemaVersion: 1, tileset: parsed.tileset };
+      if (options.json) return emitJson(document);
+      const item = parsed.tileset;
+      console.log(`${pc3.bold(item.name)} ${pc3.gray(item.state)}`);
+      console.log(`  ID: ${item.id}`);
+      console.log(`  Current version: ${String(item.currentVersion ?? "unpublished")}`);
+    } catch {
+      emitFailure(options.json, "tileset_status_failed", "Tileset status failed.");
+    }
+  });
+  tileset.command("purge").description("Permanently purge one unreferenced Team tileset").argument("<id>", "Team-local logical ID or opaque resource ID").requiredOption("--confirm <id>", "repeat the exact tileset ID").option("--team <team>", "target Team as @team").addOption(hostedApiUrlOption()).addOption(hostedApiKeyOption("Team data API key")).option("--json", "print deterministic schema-version-1 JSON").action(async (id, options) => {
+    try {
+      if (!isTilesetId(id) || options.confirm !== id) {
+        return emitFailure(
+          options.json,
+          "purge_confirmation_mismatch",
+          "Purge confirmation must match the tileset ID."
+        );
+      }
+      const authority = await resolveTeamAuthority(options, ["tilesets:write"], dependencies);
+      if (!authority) return;
+      const response = await authorizedTeamRequest(
+        authority,
+        `/v1/tilesets/${encodeURIComponent(id)}`,
+        "DELETE",
+        {
+          headers: {
+            "X-Tileflow-Confirm-Tileset-Purge": id
+          }
+        }
+      );
+      if (!response.ok) {
+        const inUse = tilesetInUseResponseSchema.safeParse(response.body);
+        if (inUse.success) {
+          return emitFailure(
+            options.json,
+            inUse.data.code,
+            "Tileset is used by retained Map deployments.",
+            {
+              dependencies: inUse.data.dependencies,
+              nextCursor: inUse.data.nextCursor
+            }
+          );
+        }
+        return emitFailure(
+          options.json,
+          `http_${response.status}`,
+          `Tileset purge failed (${response.status}).`
+        );
+      }
+      const parsed = tilesetPurgeResponseSchema.parse(response.body);
+      const document = { command: "tileset purge", schemaVersion: 1, ...parsed };
+      if (options.json) return emitJson(document);
+      console.log(`${pc3.green("\u2713")} Purge ${parsed.reclamation}.`);
+    } catch {
+      emitFailure(options.json, "tileset_purge_failed", "Tileset purge failed.");
+    }
+  });
+}
+async function fetchAllTeamTilesets(authority) {
+  const items = [];
+  const seenCursors = /* @__PURE__ */ new Set();
+  const seenIds = /* @__PURE__ */ new Set();
+  let cursor = null;
+  for (let page = 0; page < 100; page += 1) {
+    const query = new URLSearchParams({ limit: "100" });
+    if (cursor) query.set("cursor", cursor);
+    const response = await authorizedTeamRequest(
+      authority,
+      `/v1/tilesets?${query.toString()}`,
+      "GET"
+    );
+    if (!response.ok) {
+      throw new TeamTilesetUploadError(
+        `http_${response.status}`,
+        `Tileset list failed (${response.status}).`
+      );
+    }
+    const parsed = tilesetListResponseSchema.parse(response.body);
+    for (const item of parsed.tilesets) {
+      if (seenIds.has(item.id)) throw new Error("Tileset list returned a duplicate resource.");
+      const previous = items.at(-1);
+      if (previous && (previous.logicalName > item.logicalName || previous.logicalName === item.logicalName && previous.id >= item.id)) {
+        throw new Error("Tileset list returned unstable ordering.");
+      }
+      seenIds.add(item.id);
+      items.push(item);
+    }
+    cursor = parsed.nextCursor ?? null;
+    if (!cursor) return Object.freeze(items);
+    if (seenCursors.has(cursor)) throw new Error("Tileset list repeated a cursor.");
+    seenCursors.add(cursor);
+  }
+  throw new Error("Tileset list exceeded its safe page limit.");
+}
+function isTilesetId(value) {
+  return /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(value) && !["terrain", "world"].includes(value);
+}
+function parseIncludedValueFields(value) {
+  if (value === void 0) return void 0;
+  const fields = value.split(",").map((field) => field.trim());
+  if (fields.some((field) => !field)) {
+    throw inspectionOptionError("--include-values requires comma-separated field names.");
+  }
+  return fields;
+}
+function inspectionOptionError(message) {
+  return Object.assign(new Error(message), {
+    code: "TF_TILESET_INSPECTION_OPTIONS_INVALID",
+    path: "includeValues"
+  });
+}
+function asRecord3(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+var safeIdentifierSchema2 = z4.string().min(1).max(160).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u);
+var physicalTilesetIdSchema = z4.string().min(20).max(80).regex(/^tls_[A-Za-z0-9_-]+$/u);
+var cursorSchema = z4.string().min(1).max(2048).nullable();
+var tilesetInventoryItemSchema = z4.object({
+  currentVersion: z4.number().int().positive().max(Number.MAX_SAFE_INTEGER).nullable(),
+  hasCurrent: z4.boolean(),
+  id: physicalTilesetIdSchema,
+  logicalName: z4.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u),
+  name: z4.string().min(1).max(200),
+  retainedBytes: z4.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+  retainedDeploymentCount: z4.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+  status: z4.enum(["active", "purging", "retired"]),
+  updatedAt: z4.iso.datetime({ offset: true }),
+  usedByMapCount: z4.number().int().min(0).max(Number.MAX_SAFE_INTEGER)
+}).strict();
+var tilesetListResponseSchema = z4.object({
+  nextCursor: cursorSchema.optional(),
+  schemaVersion: z4.literal(1),
+  tilesets: z4.array(tilesetInventoryItemSchema).max(100)
+}).strict();
+var tilesetDependencySchema = z4.object({
+  active: z4.boolean(),
+  deploymentId: safeIdentifierSchema2,
+  deploymentVersion: z4.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  environment: z4.string().min(1).max(64),
+  mapId: safeIdentifierSchema2,
+  sourceId: safeIdentifierSchema2
+}).strict();
+var tilesetDetailResponseSchema = z4.object({
+  schemaVersion: z4.literal(1),
+  tileset: z4.object({
+    attribution: z4.string().max(4096).nullable(),
+    currentVersion: z4.number().int().positive().max(Number.MAX_SAFE_INTEGER).nullable(),
+    dependencies: z4.array(tilesetDependencySchema).max(25),
+    dependencyNextCursor: cursorSchema,
+    id: physicalTilesetIdSchema,
+    name: z4.string().min(1).max(200),
+    slug: z4.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u),
+    state: z4.enum(["active", "purging", "purged"])
+  }).strict()
+}).strict();
+var purgeDependencySchema = z4.object({
+  deploymentId: safeIdentifierSchema2,
+  mapId: safeIdentifierSchema2,
+  sourceId: safeIdentifierSchema2
+}).strict();
+var tilesetInUseResponseSchema = z4.object({
+  code: z4.literal("TF_TILESET_IN_USE"),
+  dependencies: z4.array(purgeDependencySchema).max(32),
+  error: z4.literal("Tileset is used by retained Map deployments"),
+  nextCursor: cursorSchema
+}).strict();
+var tilesetPurgeResponseSchema = z4.object({
+  deliveryFence: z4.enum(["complete", "pending"]),
+  pendingVersions: z4.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+  reclamation: z4.enum(["complete", "pending"]),
+  state: z4.enum(["purged", "purging"]),
+  tilesetId: physicalTilesetIdSchema
+}).strict();
+
+export {
+  rejectedAccountSessionMessage,
+  prepareAccountLogin,
+  loadAuthConfig,
+  installAccountSession,
+  resolveAccountSession,
+  removeAccountSession,
+  writeAuthFileAtomic,
+  removeAuthFile,
+  normalizeApiOrigin,
+  parseProjectReference,
+  createCliProgram,
+  hostedApiKeyOption,
+  hostedApiUrlOption,
+  isHostedApiKey,
+  apiProfileCanTargetMap,
+  requestHostedJson,
+  startDeviceAuthorization,
+  pollDeviceToken,
+  validateAccountSession,
+  validateApiKey,
+  requestMapCapability,
+  listMapSetupTeams,
+  createManagedMapSetup,
+  publishHostedStyle,
+  assertHostedStyleBudget,
+  uploadHostedIconPackage,
+  uploadHostedFontBundle,
+  fetchHostedMapStatus,
+  revokeHostedAccountSession,
+  resolveTeamAuthority,
+  authorizedTeamRequest,
+  emitJson,
+  emitFailure,
+  safeMessage,
+  registerTilesetInspectCommand,
+  registerTilesetCommands
+};