@apptile/tile-cli 0.1.0-beta.0

package/dist/index.js

@@ -0,0 +1,4469 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target2) => (target2 = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target2, "default", { value: mod, enumerable: true }) : target2,
+  mod
+));
+
+// ../core/dist/output.js
+var require_output = __commonJS({
+  "../core/dist/output.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.ExitCode = void 0;
+    exports2.setJsonMode = setJsonMode2;
+    exports2.isJsonMode = isJsonMode12;
+    exports2.out = out12;
+    exports2.hint = hint13;
+    exports2.info = info12;
+    exports2.ExitCode = {
+      OK: 0,
+      ERROR: 1,
+      // generic failure
+      USAGE: 2,
+      // bad arguments (commander also uses 1; we use 2 for our own checks)
+      AUTH: 3,
+      // not authenticated / 401 / 403
+      NOT_FOUND: 4,
+      // 404
+      CONFLICT: 5,
+      // 409 (e.g. optimistic-lock failure)
+      NETWORK: 6,
+      // could not reach the backend
+      UNSUPPORTED: 7
+      // capability not available for this project (e.g. no test flows configured)
+    };
+    var jsonMode = false;
+    function setJsonMode2(on) {
+      jsonMode = on;
+    }
+    function isJsonMode12() {
+      return jsonMode;
+    }
+    function out12(value) {
+      if (jsonMode) {
+        process.stdout.write(JSON.stringify(value, null, 2) + "\n");
+        return;
+      }
+      if (typeof value === "string") {
+        process.stdout.write(value + "\n");
+        return;
+      }
+      process.stdout.write(JSON.stringify(value, null, 2) + "\n");
+    }
+    function hint13(...lines) {
+      if (jsonMode || lines.length === 0)
+        return;
+      for (const line of lines) {
+        process.stderr.write(line + "\n");
+      }
+    }
+    function info12(line) {
+      if (jsonMode)
+        return;
+      process.stderr.write(line + "\n");
+    }
+  }
+});
+
+// ../core/dist/errors.js
+var require_errors = __commonJS({
+  "../core/dist/errors.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.TileError = void 0;
+    exports2.exitCodeForStatus = exitCodeForStatus;
+    var output_1 = require_output();
+    var TileError10 = class extends Error {
+      constructor(message, exitCode = output_1.ExitCode.ERROR, nextStep) {
+        super(message);
+        this.name = "TileError";
+        this.exitCode = exitCode;
+        this.nextStep = nextStep;
+      }
+    };
+    exports2.TileError = TileError10;
+    function exitCodeForStatus(status) {
+      switch (status) {
+        case 401:
+        case 403:
+          return output_1.ExitCode.AUTH;
+        case 404:
+          return output_1.ExitCode.NOT_FOUND;
+        case 409:
+          return output_1.ExitCode.CONFLICT;
+        default:
+          return output_1.ExitCode.ERROR;
+      }
+    }
+  }
+});
+
+// ../core/dist/auth.js
+var require_auth = __commonJS({
+  "../core/dist/auth.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.readCredentials = readCredentials;
+    exports2.getToken = getToken3;
+    exports2.requireToken = requireToken;
+    exports2.login = login2;
+    exports2.register = register2;
+    exports2.logout = logout2;
+    exports2.whoami = whoami3;
+    var fs8 = __importStar(require("fs"));
+    var os3 = __importStar(require("os"));
+    var path11 = __importStar(require("path"));
+    var http_1 = require_http();
+    var errors_1 = require_errors();
+    var output_1 = require_output();
+    function configDir() {
+      const base = process.env.XDG_CONFIG_HOME || path11.join(os3.homedir(), ".config");
+      return path11.join(base, "tile");
+    }
+    function credsPath() {
+      return path11.join(configDir(), "credentials.json");
+    }
+    function readCredentials() {
+      try {
+        const raw = fs8.readFileSync(credsPath(), "utf8");
+        return JSON.parse(raw);
+      } catch {
+        return null;
+      }
+    }
+    function writeCredentials(creds) {
+      const dir = configDir();
+      fs8.mkdirSync(dir, { recursive: true });
+      fs8.writeFileSync(credsPath(), JSON.stringify(creds, null, 2) + "\n", { mode: 384 });
+    }
+    function getToken3() {
+      if (process.env.TILE_TOKEN)
+        return process.env.TILE_TOKEN;
+      return readCredentials()?.token;
+    }
+    function requireToken() {
+      const t = getToken3();
+      if (!t) {
+        throw new errors_1.TileError("Not authenticated.", output_1.ExitCode.AUTH, "Run `tile login` or set TILE_TOKEN.");
+      }
+      return t;
+    }
+    async function login2(email, password) {
+      const res = await (0, http_1.request)("/api/auth/login", {
+        method: "POST",
+        body: { email, password },
+        token: null
+      });
+      const creds = { token: res.token, user: res.user, apiUrl: process.env.TILE_API_URL };
+      writeCredentials(creds);
+      return creds;
+    }
+    async function register2(email, password, name) {
+      const res = await (0, http_1.request)("/api/auth/register", {
+        method: "POST",
+        body: { email, password, name },
+        token: null
+      });
+      const creds = { token: res.token, user: res.user, apiUrl: process.env.TILE_API_URL };
+      writeCredentials(creds);
+      return creds;
+    }
+    function logout2() {
+      try {
+        fs8.unlinkSync(credsPath());
+      } catch {
+      }
+    }
+    async function whoami3() {
+      requireToken();
+      const res = await (0, http_1.request)("/api/auth/me");
+      return res.user;
+    }
+  }
+});
+
+// ../core/dist/http.js
+var require_http = __commonJS({
+  "../core/dist/http.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.baseUrl = baseUrl;
+    exports2.request = request;
+    var errors_1 = require_errors();
+    var output_1 = require_output();
+    var auth_1 = require_auth();
+    function baseUrl() {
+      return (process.env.TILE_API_URL || "https://demo-setup.tile.dev").replace(/\/+$/, "");
+    }
+    function buildUrl(path11, query) {
+      const url = new URL(path11.startsWith("http") ? path11 : baseUrl() + path11);
+      if (query) {
+        for (const [k, v] of Object.entries(query)) {
+          if (v !== void 0)
+            url.searchParams.set(k, String(v));
+        }
+      }
+      return url.toString();
+    }
+    async function request(path11, opts = {}) {
+      const { method = "GET", body, headers = {}, query } = opts;
+      const token = opts.token === null ? void 0 : opts.token ?? (0, auth_1.getToken)();
+      const finalHeaders = {
+        Accept: "application/json",
+        ...headers
+      };
+      if (body !== void 0)
+        finalHeaders["Content-Type"] = "application/json";
+      if (token) {
+        finalHeaders["Cookie"] = `tile_session=${token}`;
+        finalHeaders["Authorization"] = `Bearer ${token}`;
+      }
+      const url = buildUrl(path11, query);
+      let res;
+      try {
+        res = await fetch(url, {
+          method,
+          headers: finalHeaders,
+          body: body === void 0 ? void 0 : JSON.stringify(body)
+        });
+      } catch (e) {
+        throw new errors_1.TileError(`Could not reach the tile backend at ${baseUrl()}. Is the gateway up? (${e.message})`, output_1.ExitCode.NETWORK, "Start the dev stack, or set TILE_API_URL to the right host.");
+      }
+      const text = await res.text();
+      let parsed = void 0;
+      if (text) {
+        try {
+          parsed = JSON.parse(text);
+        } catch {
+          parsed = text;
+        }
+      }
+      if (!res.ok) {
+        const serverMsg = parsed && typeof parsed === "object" && "error" in parsed ? String(parsed.error) : typeof parsed === "string" && parsed ? parsed : res.statusText;
+        const code = (0, errors_1.exitCodeForStatus)(res.status);
+        let nextStep;
+        if (res.status === 401 || res.status === 403)
+          nextStep = "Run `tile login` (or set TILE_TOKEN).";
+        const err = new errors_1.TileError(`${res.status} ${serverMsg}`, code, nextStep);
+        err.status = res.status;
+        err.bodyJson = parsed;
+        throw err;
+      }
+      if (opts.raw)
+        return text;
+      return parsed;
+    }
+  }
+});
+
+// ../core/dist/config.js
+var require_config = __commonJS({
+  "../core/dist/config.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.readGlobalConfig = readGlobalConfig;
+    exports2.writeGlobalConfig = writeGlobalConfig3;
+    exports2.findConfigPath = findConfigPath3;
+    exports2.readConfig = readConfig3;
+    exports2.writeConfig = writeConfig3;
+    exports2.readProjectRegistry = readProjectRegistry2;
+    exports2.linkProject = linkProject3;
+    exports2.unlinkProject = unlinkProject2;
+    exports2.resolveProjectPath = resolveProjectPath2;
+    exports2.resolveApp = resolveApp8;
+    exports2.resolveEnv = resolveEnv2;
+    exports2.resolveAppOptional = resolveAppOptional3;
+    exports2.resolveEnvOptional = resolveEnvOptional2;
+    exports2.resolveProjectDir = resolveProjectDir2;
+    var fs8 = __importStar(require("fs"));
+    var os3 = __importStar(require("os"));
+    var path11 = __importStar(require("path"));
+    var errors_1 = require_errors();
+    var output_1 = require_output();
+    var FILE = "tile.json";
+    function globalConfigPath() {
+      const base = process.env.XDG_CONFIG_HOME || path11.join(os3.homedir(), ".config");
+      return path11.join(base, "tile", "config.json");
+    }
+    function readGlobalConfig() {
+      try {
+        return JSON.parse(fs8.readFileSync(globalConfigPath(), "utf8"));
+      } catch {
+        return {};
+      }
+    }
+    function writeGlobalConfig3(patch) {
+      const p = globalConfigPath();
+      fs8.mkdirSync(path11.dirname(p), { recursive: true });
+      const merged = { ...readGlobalConfig(), ...patch };
+      fs8.writeFileSync(p, JSON.stringify(merged, null, 2) + "\n");
+      return p;
+    }
+    function findConfigPath3(start = process.cwd()) {
+      let dir = path11.resolve(start);
+      while (true) {
+        const candidate = path11.join(dir, FILE);
+        if (fs8.existsSync(candidate))
+          return candidate;
+        const parent = path11.dirname(dir);
+        if (parent === dir)
+          return null;
+        dir = parent;
+      }
+    }
+    function readConfig3(start) {
+      const p = findConfigPath3(start);
+      if (!p)
+        return {};
+      try {
+        return JSON.parse(fs8.readFileSync(p, "utf8"));
+      } catch {
+        return {};
+      }
+    }
+    function writeConfig3(config, dir = process.cwd()) {
+      const p = path11.join(dir, FILE);
+      fs8.writeFileSync(p, JSON.stringify(config, null, 2) + "\n");
+      return p;
+    }
+    function projectsPath() {
+      const base = process.env.XDG_CONFIG_HOME || path11.join(os3.homedir(), ".config");
+      return path11.join(base, "tile", "projects.json");
+    }
+    function readProjectRegistry2() {
+      try {
+        return JSON.parse(fs8.readFileSync(projectsPath(), "utf8"));
+      } catch {
+        return {};
+      }
+    }
+    function writeProjectRegistry(reg) {
+      const p = projectsPath();
+      fs8.mkdirSync(path11.dirname(p), { recursive: true });
+      fs8.writeFileSync(p, JSON.stringify(reg, null, 2) + "\n");
+    }
+    function linkProject3(appId, dir, name) {
+      const reg = readProjectRegistry2();
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const prev = reg[appId];
+      reg[appId] = {
+        path: path11.resolve(dir),
+        name: name ?? prev?.name,
+        linkedAt: prev?.linkedAt ?? now,
+        lastUsedAt: now
+      };
+      writeProjectRegistry(reg);
+    }
+    function unlinkProject2(appId) {
+      const reg = readProjectRegistry2();
+      if (!reg[appId])
+        return false;
+      delete reg[appId];
+      writeProjectRegistry(reg);
+      return true;
+    }
+    function resolveProjectPath2(appId) {
+      const reg = readProjectRegistry2();
+      const link = reg[appId];
+      if (!link)
+        return void 0;
+      if (!fs8.existsSync(link.path)) {
+        delete reg[appId];
+        try {
+          writeProjectRegistry(reg);
+        } catch {
+        }
+        return void 0;
+      }
+      return link.path;
+    }
+    function resolveApp8(opts = {}) {
+      const app = opts.app || readConfig3().appId || process.env.TILE_APP || readGlobalConfig().appId;
+      if (!app) {
+        throw new errors_1.TileError("No app specified.", output_1.ExitCode.USAGE, "Run `tile use <appId>`, pass --app, add it to tile.json, or set TILE_APP.");
+      }
+      return app;
+    }
+    function resolveEnv2(opts = {}) {
+      const env = opts.env || readConfig3().env || process.env.TILE_ENV || readGlobalConfig().env;
+      if (!env) {
+        throw new errors_1.TileError("No environment specified.", output_1.ExitCode.USAGE, "Pass --env <env>, add it to tile.json, or set TILE_ENV.");
+      }
+      return env;
+    }
+    function resolveAppOptional3(opts = {}) {
+      return opts.app || readConfig3().appId || process.env.TILE_APP || readGlobalConfig().appId;
+    }
+    function resolveEnvOptional2(opts = {}) {
+      return opts.env || readConfig3().env || process.env.TILE_ENV || readGlobalConfig().env;
+    }
+    function resolveProjectDir2(opts = {}) {
+      const cfgPath = findConfigPath3();
+      if (cfgPath)
+        return path11.dirname(cfgPath);
+      const appId = opts.app || process.env.TILE_APP || readGlobalConfig().appId;
+      if (appId) {
+        const p = resolveProjectPath2(appId);
+        if (p) {
+          linkProject3(appId, p);
+          return p;
+        }
+        throw new errors_1.TileError(`No local repo is linked for app ${appId} on this machine (it may have moved).`, output_1.ExitCode.USAGE, `cd into its folder, or run \`tile pull --app ${appId}\` to fetch it.`);
+      }
+      throw new errors_1.TileError("Not inside a Tile app and no app selected.", output_1.ExitCode.USAGE, "cd into a Tile app, run `tile use <appId>`, or pass --app.");
+    }
+  }
+});
+
+// ../core/dist/liveLayer.js
+var require_liveLayer = __commonJS({
+  "../core/dist/liveLayer.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.getCurrent = getCurrent2;
+    exports2.publish = publish;
+    exports2.listVersions = listVersions2;
+    exports2.getVersion = getVersion;
+    exports2.rollback = rollback;
+    exports2.listLayers = listLayers2;
+    exports2.deleteLayer = deleteLayer2;
+    exports2.publishMutating = publishMutating2;
+    exports2.parseCategoryArg = parseCategoryArg2;
+    exports2.setInPath = setInPath2;
+    exports2.unsetInPath = unsetInPath2;
+    exports2.getInPath = getInPath2;
+    exports2.parseValue = parseValue2;
+    var http_1 = require_http();
+    var enc = encodeURIComponent;
+    function catQuery(category) {
+      return category ? { category } : void 0;
+    }
+    function getCurrent2(app, env, category = "") {
+      return (0, http_1.request)(`/api/apps/${enc(app)}/live-layer/${enc(env)}`, {
+        query: catQuery(category)
+      });
+    }
+    function publish(app, env, config, baseVersion, category = "", note) {
+      return (0, http_1.request)(`/api/apps/${enc(app)}/live-layer/${enc(env)}/publish`, {
+        method: "POST",
+        body: { config, baseVersion, category, note }
+      });
+    }
+    async function listVersions2(app, env, category = "") {
+      const res = await (0, http_1.request)(`/api/apps/${enc(app)}/live-layer/${enc(env)}/versions`, { query: catQuery(category) });
+      return res.versions || [];
+    }
+    function getVersion(app, env, version, category = "") {
+      return (0, http_1.request)(`/api/apps/${enc(app)}/live-layer/${enc(env)}/versions/${version}`, {
+        query: catQuery(category)
+      });
+    }
+    function rollback(app, env, toVersion, category = "") {
+      return (0, http_1.request)(`/api/apps/${enc(app)}/live-layer/${enc(env)}/rollback`, {
+        method: "POST",
+        body: { toVersion, category }
+      });
+    }
+    async function listLayers2(app, env) {
+      const res = await (0, http_1.request)(`/api/apps/${enc(app)}/live-layer/${enc(env)}/layers`);
+      return res.layers || [];
+    }
+    function deleteLayer2(app, env, category) {
+      return (0, http_1.request)(`/api/apps/${enc(app)}/live-layer/${enc(env)}/layers`, {
+        method: "DELETE",
+        query: { category }
+      });
+    }
+    async function publishMutating2(app, env, category, mutate) {
+      let lastErr;
+      for (let attempt = 0; attempt < 2; attempt++) {
+        const cur = await getCurrent2(app, env, category);
+        let start = cur.config || {};
+        if (category && !cur.published) {
+          const base = await getCurrent2(app, env, "");
+          start = base.config || {};
+        }
+        const next = JSON.parse(JSON.stringify(start));
+        mutate(next);
+        try {
+          return await publish(app, env, next, cur.version || 0, category);
+        } catch (e) {
+          lastErr = e;
+          const status = e.status;
+          if (status === 409 && attempt === 0)
+            continue;
+          throw e;
+        }
+      }
+      throw lastErr;
+    }
+    function parseCategoryArg2(raw) {
+      if (!raw)
+        return "";
+      return raw.split(/[/,]/).map((s) => s.trim()).filter((s) => s.length > 0).join("/");
+    }
+    function setInPath2(obj, dotted, value) {
+      const parts = dotted.split(".").filter((p) => p.length > 0);
+      let node = obj;
+      for (let i = 0; i < parts.length - 1; i++) {
+        const k = parts[i];
+        if (node[k] === null || typeof node[k] !== "object" || Array.isArray(node[k]))
+          node[k] = {};
+        node = node[k];
+      }
+      node[parts[parts.length - 1]] = value;
+    }
+    function unsetInPath2(obj, dotted) {
+      const parts = dotted.split(".").filter((p) => p.length > 0);
+      let node = obj;
+      for (let i = 0; i < parts.length - 1; i++) {
+        const k = parts[i];
+        if (node[k] === null || typeof node[k] !== "object")
+          return;
+        node = node[k];
+      }
+      delete node[parts[parts.length - 1]];
+    }
+    function getInPath2(obj, dotted) {
+      const parts = dotted.split(".").filter((p) => p.length > 0);
+      let node = obj;
+      for (const k of parts) {
+        if (node === null || typeof node !== "object" || Array.isArray(node))
+          return void 0;
+        node = node[k];
+      }
+      return node;
+    }
+    function parseValue2(raw) {
+      if (raw === "true")
+        return true;
+      if (raw === "false")
+        return false;
+      if (raw === "null")
+        return null;
+      if (/^-?\d+(\.\d+)?$/.test(raw))
+        return Number(raw);
+      const t = raw.trim();
+      if (t.startsWith("{") || t.startsWith("[")) {
+        try {
+          return JSON.parse(t);
+        } catch {
+        }
+      }
+      return raw;
+    }
+  }
+});
+
+// ../core/dist/build.js
+var require_build = __commonJS({
+  "../core/dist/build.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.isTerminalStatus = isTerminalStatus3;
+    exports2.listBuilds = listBuilds3;
+    exports2.getBuild = getBuild2;
+    exports2.getLogs = getLogs2;
+    exports2.cancelBuild = cancelBuild2;
+    exports2.createBuild = createBuild2;
+    exports2.startBuild = startBuild2;
+    exports2.getCredentials = getCredentials2;
+    exports2.uploadAndroidKeystore = uploadAndroidKeystore2;
+    exports2.deleteAndroidKeystore = deleteAndroidKeystore2;
+    exports2.uploadIosAscKey = uploadIosAscKey2;
+    exports2.deleteIosAscKey = deleteIosAscKey2;
+    exports2.setIosTeamId = setIosTeamId2;
+    exports2.listEnvVars = listEnvVars2;
+    exports2.upsertEnvVar = upsertEnvVar3;
+    exports2.deleteEnvVar = deleteEnvVar2;
+    exports2.getVersioning = getVersioning2;
+    exports2.setVersioning = setVersioning2;
+    exports2.getEasConfig = getEasConfig2;
+    exports2.submitBuild = submitBuild2;
+    exports2.listSubmissions = listSubmissions2;
+    exports2.getSubmission = getSubmission2;
+    exports2.getSubmissionLogs = getSubmissionLogs2;
+    exports2.cancelSubmission = cancelSubmission2;
+    exports2.listDevices = listDevices2;
+    exports2.createDevice = createDevice2;
+    exports2.removeDevice = removeDevice2;
+    exports2.getPlayCredentials = getPlayCredentials2;
+    exports2.uploadPlayServiceAccount = uploadPlayServiceAccount2;
+    exports2.deletePlayServiceAccount = deletePlayServiceAccount2;
+    exports2.storeAppCheck = storeAppCheck2;
+    exports2.createTest = createTest2;
+    exports2.getTest = getTest2;
+    exports2.listTests = listTests3;
+    exports2.cancelTest = cancelTest2;
+    var http_1 = require_http();
+    var enc = encodeURIComponent;
+    var BASE = "/build-api/v1";
+    var TERMINAL = ["finished", "errored", "canceled", "timed_out"];
+    function isTerminalStatus3(status) {
+      return TERMINAL.includes(status);
+    }
+    async function listBuilds3(appId) {
+      const res = await (0, http_1.request)(`${BASE}/apps/${enc(appId)}/builds`);
+      return res.builds || [];
+    }
+    async function getBuild2(id) {
+      return (0, http_1.request)(`${BASE}/builds/${enc(id)}`);
+    }
+    async function getLogs2(id, after = 0) {
+      return (0, http_1.request)(`${BASE}/builds/${enc(id)}/logs`, { query: { after } });
+    }
+    async function cancelBuild2(id) {
+      return (0, http_1.request)(`${BASE}/builds/${enc(id)}/cancel`, { method: "POST" });
+    }
+    async function createBuild2(appId, opts) {
+      return (0, http_1.request)(`${BASE}/apps/${enc(appId)}/builds`, {
+        method: "POST",
+        body: {
+          platform: opts.platform,
+          profile: opts.profile,
+          buildType: opts.buildType,
+          source: opts.source,
+          sourceObject: opts.sourceObject,
+          ref: opts.ref,
+          ...opts.saveId ? { saveId: opts.saveId } : {},
+          ...opts.simulator ? { simulator: true } : {},
+          triggerSource: "cli"
+        }
+      });
+    }
+    async function startBuild2(id) {
+      return (0, http_1.request)(`${BASE}/builds/${enc(id)}/start`, { method: "POST" });
+    }
+    function getCredentials2(appId) {
+      return (0, http_1.request)(`${BASE}/apps/${enc(appId)}/credentials`);
+    }
+    function uploadAndroidKeystore2(appId, input) {
+      return (0, http_1.request)(`${BASE}/apps/${enc(appId)}/credentials/android/keystore`, {
+        method: "POST",
+        body: input
+      });
+    }
+    function deleteAndroidKeystore2(appId) {
+      return (0, http_1.request)(`${BASE}/apps/${enc(appId)}/credentials/android/keystore`, { method: "DELETE" });
+    }
+    function uploadIosAscKey2(appId, input) {
+      return (0, http_1.request)(`${BASE}/apps/${enc(appId)}/credentials/ios/asc-api-key`, {
+        method: "POST",
+        body: input
+      });
+    }
+    function deleteIosAscKey2(appId) {
+      return (0, http_1.request)(`${BASE}/apps/${enc(appId)}/credentials/ios/asc-api-key`, { method: "DELETE" });
+    }
+    function setIosTeamId2(appId, teamId) {
+      return (0, http_1.request)(`${BASE}/apps/${enc(appId)}/credentials/ios/asc-api-key`, {
+        method: "PATCH",
+        body: { teamId }
+      });
+    }
+    async function listEnvVars2(appId) {
+      const res = await (0, http_1.request)(`${BASE}/apps/${enc(appId)}/env-vars`);
+      return res.envVars || [];
+    }
+    function upsertEnvVar3(appId, input) {
+      return (0, http_1.request)(`${BASE}/apps/${enc(appId)}/env-vars`, { method: "POST", body: input });
+    }
+    function deleteEnvVar2(appId, id) {
+      return (0, http_1.request)(`${BASE}/apps/${enc(appId)}/env-vars/${enc(id)}`, {
+        method: "DELETE"
+      });
+    }
+    function getVersioning2(appId, platform = "android") {
+      return (0, http_1.request)(`${BASE}/apps/${enc(appId)}/versioning`, { query: { platform } });
+    }
+    function setVersioning2(appId, input) {
+      return (0, http_1.request)(`${BASE}/apps/${enc(appId)}/versioning`, { method: "PUT", body: input });
+    }
+    function getEasConfig2(appId) {
+      return (0, http_1.request)(`${BASE}/apps/${enc(appId)}/eas-config`);
+    }
+    function submitBuild2(buildId, opts) {
+      return (0, http_1.request)(`${BASE}/builds/${enc(buildId)}/submit`, {
+        method: "POST",
+        body: {
+          mode: opts.mode,
+          ...opts.destination ? { destination: opts.destination } : {},
+          ...opts.rollout != null ? { rollout: opts.rollout } : {},
+          triggerSource: "cli"
+        }
+      });
+    }
+    async function listSubmissions2(appId) {
+      const res = await (0, http_1.request)(`${BASE}/apps/${enc(appId)}/submissions`);
+      return res.submissions || [];
+    }
+    function getSubmission2(id) {
+      return (0, http_1.request)(`${BASE}/submissions/${enc(id)}`);
+    }
+    function getSubmissionLogs2(id, after) {
+      return (0, http_1.request)(`${BASE}/submissions/${enc(id)}/logs`, {
+        query: after ? { after } : void 0
+      });
+    }
+    function cancelSubmission2(id) {
+      return (0, http_1.request)(`${BASE}/submissions/${enc(id)}/cancel`, { method: "POST" });
+    }
+    async function listDevices2(appId) {
+      const res = await (0, http_1.request)(`${BASE}/apps/${enc(appId)}/devices`);
+      return res.devices || [];
+    }
+    function createDevice2(appId, input) {
+      return (0, http_1.request)(`${BASE}/apps/${enc(appId)}/devices`, { method: "POST", body: input });
+    }
+    function removeDevice2(appId, id) {
+      return (0, http_1.request)(`${BASE}/apps/${enc(appId)}/devices/${enc(id)}`, { method: "DELETE" });
+    }
+    async function getPlayCredentials2(appId) {
+      return (0, http_1.request)(`${BASE}/apps/${enc(appId)}/credentials/play`);
+    }
+    function uploadPlayServiceAccount2(appId, input) {
+      return (0, http_1.request)(`${BASE}/apps/${enc(appId)}/credentials/android/play-service-account`, { method: "POST", body: input });
+    }
+    function deletePlayServiceAccount2(appId) {
+      return (0, http_1.request)(`${BASE}/apps/${enc(appId)}/credentials/android/play-service-account`, { method: "DELETE" });
+    }
+    function storeAppCheck2(appId, platform, identifier) {
+      return (0, http_1.request)(`${BASE}/apps/${enc(appId)}/store-app-check`, {
+        query: { platform, identifier }
+      });
+    }
+    function createTest2(appId, opts) {
+      return (0, http_1.request)(`${BASE}/apps/${enc(appId)}/tests`, {
+        method: "POST",
+        body: {
+          buildId: opts.buildId,
+          platform: opts.platform ?? "android",
+          triggerSource: opts.triggerSource ?? "cli"
+        }
+      });
+    }
+    function getTest2(id) {
+      return (0, http_1.request)(`${BASE}/tests/${enc(id)}`);
+    }
+    async function listTests3(appId) {
+      const res = await (0, http_1.request)(`${BASE}/apps/${enc(appId)}/tests`);
+      return res.tests || [];
+    }
+    function cancelTest2(id) {
+      return (0, http_1.request)(`${BASE}/tests/${enc(id)}/cancel`, { method: "POST" });
+    }
+  }
+});
+
+// ../core/dist/app.js
+var require_app = __commonJS({
+  "../core/dist/app.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.createApp = createApp3;
+    exports2.listApps = listApps2;
+    exports2.getApp = getApp2;
+    exports2.deleteApp = deleteApp2;
+    exports2.listBlueprints = listBlueprints2;
+    var http_1 = require_http();
+    var enc = encodeURIComponent;
+    async function createApp3(name, blueprint) {
+      return (0, http_1.request)("/api/apps", {
+        method: "POST",
+        body: { name, ...blueprint ? { blueprint } : {} }
+      });
+    }
+    async function listApps2() {
+      const res = await (0, http_1.request)("/api/apps");
+      return res.apps || [];
+    }
+    async function getApp2(id) {
+      const res = await (0, http_1.request)(`/api/apps/${enc(id)}`);
+      return res.app;
+    }
+    async function deleteApp2(id) {
+      return (0, http_1.request)(`/api/apps/${enc(id)}`, { method: "DELETE" });
+    }
+    async function listBlueprints2() {
+      const res = await (0, http_1.request)("/api/blueprints");
+      return res.blueprints || [];
+    }
+  }
+});
+
+// ../core/dist/source.js
+var require_source = __commonJS({
+  "../core/dist/source.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.getFiles = getFiles2;
+    exports2.getSaveFileContents = getSaveFileContents;
+    exports2.getSaveFiles = getSaveFiles2;
+    exports2.getCurrentFiles = getCurrentFiles2;
+    exports2.listSaves = listSaves2;
+    exports2.getSaveManifest = getSaveManifest2;
+    exports2.getLatestSaveMeta = getLatestSaveMeta2;
+    exports2.pushSave = pushSave2;
+    var http_1 = require_http();
+    var enc = encodeURIComponent;
+    async function getFiles2(appId) {
+      const res = await (0, http_1.request)(`/api/apps/${enc(appId)}/files`);
+      return res.files || {};
+    }
+    async function getSaveFileContents(appId, saveId, filePath) {
+      return (0, http_1.request)(`/api/apps/${enc(appId)}/saves/${enc(saveId)}/file`, {
+        query: { path: filePath },
+        raw: true
+      });
+    }
+    async function getSaveFiles2(appId, saveId) {
+      const manifest = await getSaveManifest2(appId, saveId);
+      const entries = manifest?.files ?? [];
+      const map = {};
+      let cursor = 0;
+      const worker = async () => {
+        for (; ; ) {
+          const i = cursor++;
+          if (i >= entries.length)
+            return;
+          const f = entries[i];
+          const path11 = f.path ?? f.filePath;
+          if (!path11)
+            continue;
+          const contents = await getSaveFileContents(appId, saveId, path11);
+          map[path11] = { contents, type: f.type ?? "CODE" };
+        }
+      };
+      const workerCount = Math.min(8, entries.length);
+      await Promise.all(Array.from({ length: workerCount }, () => worker()));
+      return map;
+    }
+    async function getCurrentFiles2(appId) {
+      const saves = await listSaves2(appId);
+      if (!saves.length)
+        return getFiles2(appId);
+      return getSaveFiles2(appId, saves[0]);
+    }
+    async function listSaves2(appId) {
+      const res = await (0, http_1.request)(`/api/apps/${enc(appId)}/saves`);
+      return res.saves || [];
+    }
+    async function getSaveManifest2(appId, saveId) {
+      const res = await (0, http_1.request)(`/api/apps/${enc(appId)}/saves/${enc(saveId)}`);
+      return res.manifest || null;
+    }
+    async function getLatestSaveMeta2(appId) {
+      const saves = await listSaves2(appId);
+      if (!saves.length)
+        return null;
+      const m = await getSaveManifest2(appId, saves[0]);
+      if (!m)
+        return null;
+      return { sdkVersion: m.sdkVersion, dependencies: m.dependencies };
+    }
+    async function pushSave2(appId, input) {
+      return (0, http_1.request)(`/api/apps/${enc(appId)}/saves`, {
+        method: "POST",
+        body: {
+          files: input.files,
+          dependencies: input.dependencies ?? {},
+          sdkVersion: input.sdkVersion ?? "54.0.0",
+          branch: input.branch ?? null
+        }
+      });
+    }
+  }
+});
+
+// ../core/dist/assets.js
+var require_assets = __commonJS({
+  "../core/dist/assets.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.uploadAsset = uploadAsset2;
+    exports2.listAssets = listAssets2;
+    exports2.deleteAsset = deleteAsset2;
+    var fs8 = __importStar(require("fs"));
+    var path11 = __importStar(require("path"));
+    var errors_1 = require_errors();
+    var output_1 = require_output();
+    var auth_1 = require_auth();
+    var http_1 = require_http();
+    var MIME = {
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".gif": "image/gif",
+      ".svg": "image/svg+xml",
+      ".webp": "image/webp",
+      ".mp4": "video/mp4",
+      ".webm": "video/webm",
+      ".mov": "video/quicktime",
+      ".ttf": "font/ttf",
+      ".otf": "font/otf",
+      ".woff": "font/woff",
+      ".woff2": "font/woff2"
+    };
+    function mimeFor(file) {
+      return MIME[path11.extname(file).toLowerCase()] || "application/octet-stream";
+    }
+    var enc = encodeURIComponent;
+    function authHeaders() {
+      const token = (0, auth_1.getToken)();
+      if (!token)
+        return {};
+      return { Cookie: `tile_session=${token}`, Authorization: `Bearer ${token}` };
+    }
+    async function uploadAsset2(appId, filePath) {
+      let data;
+      try {
+        data = await fs8.promises.readFile(filePath);
+      } catch (e) {
+        throw new errors_1.TileError(`Could not read file "${filePath}" (${e.message}).`, output_1.ExitCode.USAGE, "Pass a path to an existing local file.");
+      }
+      const name = path11.basename(filePath);
+      const form = new FormData();
+      form.append("file", new Blob([data], { type: mimeFor(name) }), name);
+      const url = `${(0, http_1.baseUrl)()}/api/apps/${enc(appId)}/assets`;
+      let res;
+      try {
+        res = await fetch(url, { method: "POST", headers: authHeaders(), body: form });
+      } catch (e) {
+        throw new errors_1.TileError(`Could not reach the tile backend at ${(0, http_1.baseUrl)()}. Is the gateway up? (${e.message})`, output_1.ExitCode.NETWORK, "Start the dev stack, or set TILE_API_URL to the right host.");
+      }
+      const text = await res.text();
+      let parsed;
+      try {
+        parsed = text ? JSON.parse(text) : void 0;
+      } catch {
+        parsed = text;
+      }
+      if (!res.ok) {
+        const msg = parsed && typeof parsed === "object" && "error" in parsed ? String(parsed.error) : typeof parsed === "string" && parsed ? parsed : res.statusText;
+        throw new errors_1.TileError(`${res.status} ${msg}`, (0, errors_1.exitCodeForStatus)(res.status), res.status === 401 || res.status === 403 ? "Run `tile login` (or set TILE_TOKEN)." : void 0);
+      }
+      const asset = parsed;
+      return { ...asset, absoluteUrl: (0, http_1.baseUrl)() + asset.url };
+    }
+    async function listAssets2(appId) {
+      const url = `${(0, http_1.baseUrl)()}/api/apps/${enc(appId)}/assets`;
+      const res = await fetch(url, { headers: { Accept: "application/json", ...authHeaders() } });
+      const body = await res.json().catch(() => ({}));
+      if (!res.ok) {
+        throw new errors_1.TileError(`${res.status} ${body.error || res.statusText}`, (0, errors_1.exitCodeForStatus)(res.status));
+      }
+      return body.assets || [];
+    }
+    async function deleteAsset2(appId, assetId) {
+      const url = `${(0, http_1.baseUrl)()}/api/apps/${enc(appId)}/assets/${enc(assetId)}`;
+      const res = await fetch(url, { method: "DELETE", headers: { Accept: "application/json", ...authHeaders() } });
+      if (!res.ok) {
+        const body = await res.json().catch(() => ({}));
+        throw new errors_1.TileError(`${res.status} ${body.error || res.statusText}`, (0, errors_1.exitCodeForStatus)(res.status));
+      }
+    }
+  }
+});
+
+// ../core/dist/github.js
+var require_github = __commonJS({
+  "../core/dist/github.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.getGithubStatus = getGithubStatus2;
+    exports2.getInstallUrl = getInstallUrl2;
+    exports2.disconnectGithub = disconnectGithub2;
+    exports2.listUserRepos = listUserRepos2;
+    exports2.connectRepo = connectRepo2;
+    exports2.githubPush = githubPush2;
+    exports2.getBranchDrift = getBranchDrift2;
+    exports2.materializeBranch = materializeBranch2;
+    var http_1 = require_http();
+    var enc = encodeURIComponent;
+    function getGithubStatus2(appId) {
+      return (0, http_1.request)(`/api/apps/${enc(appId)}/github`);
+    }
+    async function getInstallUrl2(appId, returnTo) {
+      const res = await (0, http_1.request)(`/api/github/install-url`, {
+        query: { appId, ...returnTo ? { returnTo } : {} }
+      });
+      return res.url;
+    }
+    function disconnectGithub2(appId) {
+      return (0, http_1.request)(`/api/apps/${enc(appId)}/github/disconnect`, {
+        method: "POST"
+      });
+    }
+    async function listUserRepos2(appId, page = 1, perPage = 30) {
+      return (0, http_1.request)(`/api/apps/${enc(appId)}/github/user-repos`, { query: { page, perPage } });
+    }
+    function connectRepo2(appId, owner, repo) {
+      return (0, http_1.request)(`/api/apps/${enc(appId)}/github/connect-repo`, { method: "POST", body: { owner, repo } });
+    }
+    function githubPush2(appId, opts = {}) {
+      return (0, http_1.request)(`/api/apps/${enc(appId)}/github/push`, {
+        method: "POST",
+        body: { branch: opts.branch, message: opts.message }
+      });
+    }
+    function getBranchDrift2(appId, branch) {
+      return (0, http_1.request)(`/api/apps/${enc(appId)}/branches/${enc(branch)}/drift`);
+    }
+    function materializeBranch2(appId, branch) {
+      return (0, http_1.request)(`/api/apps/${enc(appId)}/branches/${enc(branch)}/materialize`, { method: "POST" });
+    }
+  }
+});
+
+// ../core/dist/integrations.js
+var require_integrations = __commonJS({
+  "../core/dist/integrations.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.listIntegrations = listIntegrations2;
+    exports2.connectIntegration = connectIntegration2;
+    exports2.disconnectIntegration = disconnectIntegration2;
+    exports2.resolveIntegration = resolveIntegration2;
+    var http_1 = require_http();
+    var enc = encodeURIComponent;
+    function listIntegrations2(appId) {
+      return (0, http_1.request)(`/api/apps/${enc(appId)}/integrations`);
+    }
+    function connectIntegration2(appId, provider, body) {
+      return (0, http_1.request)(`/api/apps/${enc(appId)}/integrations/${enc(provider)}/connect`, {
+        method: "POST",
+        body
+      });
+    }
+    function disconnectIntegration2(appId, provider, category) {
+      return (0, http_1.request)(`/api/apps/${enc(appId)}/integrations/${enc(provider)}`, {
+        method: "DELETE",
+        query: category !== void 0 ? { category } : void 0
+      });
+    }
+    function resolveIntegration2(appId, provider, category) {
+      return (0, http_1.request)(`/api/apps/${enc(appId)}/integrations/${enc(provider)}/resolve`, {
+        query: category !== void 0 ? { category } : void 0
+      });
+    }
+  }
+});
+
+// ../core/dist/index.js
+var require_dist = __commonJS({
+  "../core/dist/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_output(), exports2);
+    __exportStar(require_errors(), exports2);
+    __exportStar(require_http(), exports2);
+    __exportStar(require_auth(), exports2);
+    __exportStar(require_config(), exports2);
+    __exportStar(require_liveLayer(), exports2);
+    __exportStar(require_build(), exports2);
+    __exportStar(require_app(), exports2);
+    __exportStar(require_source(), exports2);
+    __exportStar(require_assets(), exports2);
+    __exportStar(require_github(), exports2);
+    __exportStar(require_integrations(), exports2);
+  }
+});
+
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports2, module2) {
+    module2.exports = {
+      name: "@apptile/tile-cli",
+      version: "0.1.0-beta.0",
+      description: "Tile \u2014 the unified, agent-friendly CLI for Tile apps (source, live-layer, builds, OTA).",
+      license: "UNLICENSED",
+      repository: {
+        type: "git",
+        url: "git+https://github.com/clearsight-dev/tile-cli-v2.git",
+        directory: "packages/cli"
+      },
+      engines: {
+        node: ">=18"
+      },
+      bin: {
+        tile: "dist/index.js"
+      },
+      main: "dist/index.js",
+      scripts: {
+        build: "tsup",
+        typecheck: "tsc -p tsconfig.json --noEmit",
+        prepublishOnly: "npm --prefix ../core run build && npm run typecheck && npm run build"
+      },
+      dependencies: {
+        commander: "^12.1.0",
+        qrcode: "^1.5.4",
+        "qrcode-terminal": "^0.12.0",
+        "socket.io": "^4.8.3"
+      },
+      devDependencies: {
+        "@tile/core": "0.1.0",
+        "@types/qrcode": "^1.5.5",
+        tsup: "^8.3.5"
+      },
+      files: [
+        "dist",
+        "README.md"
+      ],
+      publishConfig: {
+        access: "public"
+      }
+    };
+  }
+});
+
+// src/index.ts
+var import_commander2 = require("commander");
+var import_core12 = __toESM(require_dist());
+
+// src/commands/auth.ts
+var readline = __toESM(require("readline"));
+var import_stream = require("stream");
+var import_core = __toESM(require_dist());
+function prompt(question, mask = false) {
+  if (!process.stdin.isTTY) {
+    throw new import_core.TileError(
+      "Cannot prompt for input: this is not an interactive terminal.",
+      import_core.ExitCode.USAGE,
+      "Pass the values as flags (--email/--password, plus --name for register), or set TILE_TOKEN."
+    );
+  }
+  return new Promise((resolve7) => {
+    let muted = false;
+    const mutableOut = new import_stream.Writable({
+      write(chunk, _enc, cb) {
+        if (!muted) process.stderr.write(chunk);
+        cb();
+      }
+    });
+    const rl = readline.createInterface({ input: process.stdin, output: mutableOut, terminal: true });
+    process.stderr.write(question);
+    if (mask) muted = true;
+    rl.question("", (answer) => {
+      if (mask) process.stderr.write("\n");
+      rl.close();
+      resolve7(answer.trim());
+    });
+  });
+}
+function registerAuthCommands(program2) {
+  program2.command("login").description("Authenticate with your Tile email + password and store a session token.").argument("[email]", "account email (you can also pass --email, or be prompted)").option("-e, --email <email>", "account email").option("-p, --password <password>", "account password (omit to be prompted)").action(async (emailArg, opts) => {
+    const email = opts.email || emailArg;
+    if ((!email || !opts.password) && process.stdin.isTTY) {
+      (0, import_core.info)("Log in to Tile. Enter the email and password for your account.");
+    }
+    const resolvedEmail = email || await prompt("Email: ");
+    const password = opts.password || await prompt("Password (typing is hidden): ", true);
+    const creds = await (0, import_core.login)(resolvedEmail, password);
+    if ((0, import_core.isJsonMode)()) {
+      (0, import_core.out)({ user: creds.user });
+    } else {
+      (0, import_core.info)(`Logged in as ${creds.user?.email || resolvedEmail}.`);
+      (0, import_core.hint)("Next: `tile whoami` to confirm, or `tile live-layer get` to read flags.");
+    }
+  });
+  program2.command("register").description("Create a new Tile account with email + password, then log in.").argument("[email]", "account email (you can also pass --email, or be prompted)").option("-e, --email <email>", "account email").option("-p, --password <password>", "account password (min 8 chars; omit to be prompted)").option("-n, --name <name>", "your name").action(
+    async (emailArg, opts) => {
+      const email = opts.email || emailArg;
+      if ((!email || !opts.name || !opts.password) && process.stdin.isTTY) {
+        (0, import_core.info)("Create a Tile account. Enter your email, name, and a password (min 8 chars).");
+      }
+      const resolvedEmail = email || await prompt("Email: ");
+      const name = opts.name || await prompt("Name: ");
+      const password = opts.password || await prompt("Password (min 8 chars, typing is hidden): ", true);
+      const creds = await (0, import_core.register)(resolvedEmail, password, name);
+      if ((0, import_core.isJsonMode)()) {
+        (0, import_core.out)({ user: creds.user });
+      } else {
+        (0, import_core.info)(`Account created. Logged in as ${creds.user?.email || resolvedEmail}.`);
+        (0, import_core.hint)('Next: `tile whoami` to confirm, or `tile init --name "My App"` to start a project.');
+      }
+    }
+  );
+  program2.command("logout").description("Remove the stored session token.").action(() => {
+    (0, import_core.logout)();
+    if ((0, import_core.isJsonMode)()) (0, import_core.out)({ ok: true });
+    else (0, import_core.info)("Logged out.");
+  });
+  program2.command("whoami").description("Show the currently authenticated user.").action(async () => {
+    const user = await (0, import_core.whoami)();
+    if ((0, import_core.isJsonMode)()) (0, import_core.out)({ user });
+    else (0, import_core.info)(`${user.email}${user.name ? ` (${user.name})` : ""} \u2014 id ${user.id}`);
+  });
+}
+
+// src/commands/live-layer.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var import_core2 = __toESM(require_dist());
+var DEFAULT_PUBLIC_BASE = "https://storage.googleapis.com/tile-livelayer-configs";
+function target(opts) {
+  return { app: (0, import_core2.resolveApp)(opts), env: (0, import_core2.resolveEnv)(opts), category: (0, import_core2.parseCategoryArg)(opts.category) };
+}
+function catLabel(category) {
+  return category || "(base)";
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const c of process.stdin) chunks.push(c);
+  return Buffer.concat(chunks).toString("utf8");
+}
+function registerLiveLayerCommands(program2) {
+  const ll = program2.command("live-layer", { hidden: true }).alias("ll").description("Manage remote nested config, sliced by category, for an app + environment.");
+  const LIVE_LAYER_WRITES_ENABLED = false;
+  const assertWritable = () => {
+    if (!LIVE_LAYER_WRITES_ENABLED)
+      throw new import_core2.TileError(
+        "Live Layer publishing is disabled.",
+        import_core2.ExitCode.USAGE,
+        "Remote-config writes are turned off in this CLI."
+      );
+  };
+  const withTarget = (cmd) => cmd.option("--app <appId>", "app id (or tile.json / TILE_APP)").option("--env <env>", "environment, e.g. preview/dev/prod (or tile.json / TILE_ENV)").option("--category <key>", "category, e.g. in/mumbai (omit for the base layer)");
+  withTarget(
+    ll.command("get [path]").description("Print the config, or one dotted path (e.g. home.cta.label), for a category.")
+  ).action(async (dpath, opts) => {
+    const { app, env, category } = target(opts);
+    const cur = await (0, import_core2.getCurrent)(app, env, category);
+    const config = cur.config || {};
+    if (dpath) {
+      const v = (0, import_core2.getInPath)(config, dpath);
+      if (v === void 0) throw new import_core2.TileError(`Path "${dpath}" is not set.`, import_core2.ExitCode.NOT_FOUND);
+      (0, import_core2.out)(v);
+      return;
+    }
+    if ((0, import_core2.isJsonMode)()) (0, import_core2.out)(cur);
+    else (0, import_core2.out)(config);
+    (0, import_core2.hint)(`(${catLabel(category)} v${cur.version}) Next: \`tile live-layer set <path>=<value>\` or \`tile live-layer versions\`.`);
+  });
+  withTarget(
+    ll.command("set <pairs...>").description("Set one or more dotted-path=value entries (types auto-inferred) and publish.")
+  ).action(async (pairs, opts) => {
+    assertWritable();
+    const { app, env, category } = target(opts);
+    const patch = [];
+    for (const p of pairs) {
+      const i = p.indexOf("=");
+      if (i < 0) throw new import_core2.TileError(`Bad pair "${p}" \u2014 expected path=value.`, import_core2.ExitCode.USAGE);
+      patch.push({ path: p.slice(0, i), value: (0, import_core2.parseValue)(p.slice(i + 1)) });
+    }
+    const res = await (0, import_core2.publishMutating)(
+      app,
+      env,
+      category,
+      (c) => patch.forEach(({ path: pp, value }) => (0, import_core2.setInPath)(c, pp, value))
+    );
+    if ((0, import_core2.isJsonMode)()) (0, import_core2.out)(res);
+    else (0, import_core2.info)(`\u2713 Published ${catLabel(category)} v${res.version} (${patch.length} change(s)).`);
+    (0, import_core2.hint)(
+      `Next: \`tile live-layer get --category ${category || ""}\` to verify, or \`tile live-layer rollback --to ${Math.max(res.version - 1, 1)}\` to undo.`
+    );
+  });
+  withTarget(
+    ll.command("rm <paths...>").description("Remove one or more dotted paths and publish.")
+  ).action(async (paths, opts) => {
+    assertWritable();
+    const { app, env, category } = target(opts);
+    const res = await (0, import_core2.publishMutating)(
+      app,
+      env,
+      category,
+      (c) => paths.forEach((p) => (0, import_core2.unsetInPath)(c, p))
+    );
+    if ((0, import_core2.isJsonMode)()) (0, import_core2.out)(res);
+    else (0, import_core2.info)(`\u2713 Published ${catLabel(category)} v${res.version} (removed ${paths.length}).`);
+    (0, import_core2.hint)(`Next: \`tile live-layer get\` to verify.`);
+  });
+  withTarget(
+    ll.command("publish").description("Replace the ENTIRE config for a category from a JSON file (or --stdin) and publish.").option("--file <path>", "path to a JSON config object").option("--stdin", "read the JSON object from stdin")
+  ).action(async (opts) => {
+    assertWritable();
+    const { app, env, category } = target(opts);
+    let raw;
+    if (opts.file) raw = fs.readFileSync(opts.file, "utf8");
+    else if (opts.stdin) raw = await readStdin();
+    else throw new import_core2.TileError("Provide --file <path> or --stdin.", import_core2.ExitCode.USAGE);
+    let content;
+    try {
+      content = JSON.parse(raw);
+    } catch (e) {
+      throw new import_core2.TileError(`Input is not valid JSON: ${e.message}`, import_core2.ExitCode.USAGE);
+    }
+    if (content === null || typeof content !== "object" || Array.isArray(content)) {
+      throw new import_core2.TileError("Input must be a JSON config object.", import_core2.ExitCode.USAGE);
+    }
+    const obj = content;
+    const res = await (0, import_core2.publishMutating)(app, env, category, (c) => {
+      Object.keys(c).forEach((k) => delete c[k]);
+      Object.assign(c, obj);
+    });
+    if ((0, import_core2.isJsonMode)()) (0, import_core2.out)(res);
+    else (0, import_core2.info)(`\u2713 Published ${catLabel(category)} v${res.version} (${Object.keys(res.config).length} top-level keys).`);
+    (0, import_core2.hint)(`Next: \`tile live-layer versions\` to see history.`);
+  });
+  withTarget(
+    ll.command("layers").description("List published categories for this app + environment.")
+  ).action(async (opts) => {
+    const { app, env } = target(opts);
+    const layers = await (0, import_core2.listLayers)(app, env);
+    if ((0, import_core2.isJsonMode)()) {
+      (0, import_core2.out)(layers);
+      return;
+    }
+    if (!layers.length) {
+      (0, import_core2.info)("No categories published yet.");
+    } else {
+      for (const l of layers) {
+        (0, import_core2.info)(`${catLabel(l.category)}	v${l.version}	${l.updatedBy ?? "-"}	${l.updatedAt ?? "-"}`);
+      }
+    }
+    (0, import_core2.hint)(`Next: \`tile live-layer get --category <key>\` or \`tile live-layer rm-layer <key>\`.`);
+  });
+  withTarget(
+    ll.command("rm-layer <category>").description("Delete a category entirely (its history, manifest entry, and blobs).")
+  ).action(async (categoryArg, opts) => {
+    assertWritable();
+    const { app, env } = target(opts);
+    const category = (0, import_core2.parseCategoryArg)(categoryArg);
+    if (!category) throw new import_core2.TileError("Refusing to delete the base layer.", import_core2.ExitCode.USAGE);
+    const res = await (0, import_core2.deleteLayer)(app, env, category);
+    if ((0, import_core2.isJsonMode)()) (0, import_core2.out)(res);
+    else (0, import_core2.info)(`\u2713 Deleted category ${category}.`);
+    (0, import_core2.hint)(`Next: \`tile live-layer layers\` to confirm.`);
+  });
+  withTarget(
+    ll.command("versions").description("List published versions for a category (newest first).")
+  ).action(async (opts) => {
+    const { app, env, category } = target(opts);
+    const versions = await (0, import_core2.listVersions)(app, env, category);
+    if ((0, import_core2.isJsonMode)()) {
+      (0, import_core2.out)(versions);
+      return;
+    }
+    if (!versions.length) {
+      (0, import_core2.info)(`No versions published for ${catLabel(category)}.`);
+    } else {
+      for (const v of versions) {
+        (0, import_core2.info)(`v${v.version}	${v.createdBy ?? "-"}	${v.createdAt ?? "-"}${v.note ? "	" + v.note : ""}`);
+      }
+    }
+    (0, import_core2.hint)(`Next: \`tile live-layer rollback --to <n>\` to revert.`);
+  });
+  withTarget(
+    ll.command("rollback").description("Re-publish a previous version of a category as the new current.").requiredOption("--to <version>", "the version number to roll back to")
+  ).action(async (opts) => {
+    assertWritable();
+    const { app, env, category } = target(opts);
+    const to = parseInt(opts.to, 10);
+    if (!to) throw new import_core2.TileError("--to must be a version number.", import_core2.ExitCode.USAGE);
+    const res = await (0, import_core2.rollback)(app, env, to, category);
+    if ((0, import_core2.isJsonMode)()) (0, import_core2.out)(res);
+    else (0, import_core2.info)(`\u2713 Rolled back ${catLabel(category)} to v${to} \u2192 published v${res.version}.`);
+    (0, import_core2.hint)(`Next: \`tile live-layer get\` to verify.`);
+  });
+  ll.command("pull").description("Public read of the published config (base by default) \u2192 write a bootstrap snapshot.").option("--app <appId>", "app id (or TILE_APP)").option("--env <env>", "environment (or TILE_ENV)").option("--category <key>", "pull a specific category instead of the base layer").option("--out <file>", "output path", "assets/tile-live-layer.json").option("--base-url <url>", "public storage base URL", DEFAULT_PUBLIC_BASE).action(async (opts) => {
+    const app = (0, import_core2.resolveApp)(opts);
+    const env = (0, import_core2.resolveEnv)(opts);
+    const category = (0, import_core2.parseCategoryArg)(opts.category);
+    const baseUrl = opts.baseUrl.replace(/\/+$/, "");
+    const manifestUrl = `${baseUrl}/live-layer/${app}/${env}/manifest.json`;
+    (0, import_core2.info)(`Pulling ${app}/${env} [${catLabel(category)}] from ${manifestUrl}`);
+    let config = {};
+    let version = 0;
+    try {
+      const mRes = await fetch(manifestUrl, { headers: { "Cache-Control": "no-cache" } });
+      if (!mRes.ok) throw new Error(`HTTP ${mRes.status}`);
+      const manifest = await mRes.json();
+      const layers = manifest.layers || {};
+      const layer = layers[category] || layers[""];
+      if (!layer) throw new Error("no base or matching category in manifest");
+      version = layer.version;
+      const bRes = await fetch(`${baseUrl}/${layer.blobKey}`);
+      if (!bRes.ok) throw new Error(`HTTP ${bRes.status}`);
+      const blob = await bRes.json();
+      config = blob.config || {};
+    } catch (e) {
+      (0, import_core2.info)(`  ! ${e.message} \u2014 writing empty bootstrap snapshot.`);
+    }
+    const outPath = path.resolve(process.cwd(), opts.out);
+    fs.mkdirSync(path.dirname(outPath), { recursive: true });
+    fs.writeFileSync(outPath, JSON.stringify(config, null, 2) + "\n");
+    if ((0, import_core2.isJsonMode)()) (0, import_core2.out)({ version, keys: Object.keys(config).length, file: opts.out });
+    else (0, import_core2.info)(`  \u2713 wrote ${Object.keys(config).length} top-level key(s) (v${version}) \u2192 ${opts.out}`);
+  });
+}
+
+// src/commands/build.ts
+var fs2 = __toESM(require("fs"));
+var os = __toESM(require("os"));
+var path2 = __toESM(require("path"));
+var import_child_process = require("child_process");
+var import_commander = require("commander");
+
+// src/mode.ts
+function isAgentMode() {
+  return process.env.TILE_AGENT === "1";
+}
+function blockedInAgentMode(command, instead) {
+  if (!isAgentMode()) return false;
+  console.error(
+    `\`tile ${command}\` is for local developer use and is not available in the Tile AI sandbox.
+${instead}`
+  );
+  process.exitCode = 2;
+  return true;
+}
+
+// src/commands/build.ts
+var import_core3 = __toESM(require_dist());
+
+// src/lib/qr.ts
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+var import_qrcode = __toESM(require("qrcode"));
+async function renderQr(data, outPath, opts = {}) {
+  if (!outPath) {
+    const text = await import_qrcode.default.toString(data, { type: "terminal", small: !!opts.small });
+    return { kind: "terminal", text };
+  }
+  const ext = (0, import_node_path.extname)(outPath).toLowerCase();
+  if (ext === ".svg") {
+    const svg = await import_qrcode.default.toString(data, { type: "svg", margin: 2 });
+    await (0, import_promises.writeFile)(outPath, svg, "utf8");
+  } else {
+    const buf = await import_qrcode.default.toBuffer(data, { type: "png", margin: 2, width: 512 });
+    await (0, import_promises.writeFile)(outPath, buf);
+  }
+  return { kind: "file", path: outPath };
+}
+
+// src/commands/build.ts
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var SUBMISSION_TERMINAL = ["finished", "errored", "canceled", "timed_out"];
+async function followSubmission(id) {
+  let cursor;
+  while (true) {
+    try {
+      const page = await (0, import_core3.getSubmissionLogs)(id, cursor);
+      for (const l of page.lines || []) (0, import_core3.info)(l.text);
+      if (page.nextCursor) cursor = page.nextCursor;
+    } catch {
+    }
+    const { submission } = await (0, import_core3.getSubmission)(id);
+    if (SUBMISSION_TERMINAL.includes(submission.status)) return submission;
+    await sleep(2500);
+  }
+}
+async function downloadArtifact(url, b) {
+  const ext = b.buildType === "aab" ? "aab" : b.buildType === "ipa" ? "ipa" : b.buildType === "sim" ? "tar.gz" : "apk";
+  const dest = path2.join(process.cwd(), `${b.id}.${ext}`);
+  const res = await fetch(url);
+  if (!res.ok) throw new import_core3.TileError(`Download failed: HTTP ${res.status}`, import_core3.ExitCode.ERROR);
+  fs2.writeFileSync(dest, Buffer.from(await res.arrayBuffer()));
+  return dest;
+}
+var SRC_EXCLUDES = ["node_modules", ".git", ".tile", "dist", ".expo", "build"];
+async function packAndUpload(dir, uploadUrl) {
+  if (!fs2.existsSync(path2.join(dir, "package.json"))) {
+    throw new import_core3.TileError(
+      `No package.json in ${dir} \u2014 not an Expo project.`,
+      import_core3.ExitCode.USAGE,
+      "Run from your app dir, or pass --dir. `tile init` scaffolds one."
+    );
+  }
+  const tgz = path2.join(os.tmpdir(), `tile-src-${Date.now()}.tgz`);
+  const args = ["-czf", tgz, "-C", dir, ...SRC_EXCLUDES.flatMap((e) => ["--exclude", e]), "."];
+  const r = (0, import_child_process.spawnSync)("tar", args, { stdio: "inherit" });
+  if (r.status !== 0) throw new import_core3.TileError("Failed to pack the project (tar).", import_core3.ExitCode.ERROR);
+  try {
+    const body = fs2.readFileSync(tgz);
+    let res;
+    try {
+      res = await fetch(uploadUrl, {
+        method: "PUT",
+        headers: { "Content-Type": "application/octet-stream" },
+        body
+      });
+    } catch (e) {
+      throw new import_core3.TileError(`Source upload failed: ${e.message}`, import_core3.ExitCode.NETWORK);
+    }
+    if (!res.ok) throw new import_core3.TileError(`Source upload failed: HTTP ${res.status}`, import_core3.ExitCode.ERROR);
+  } finally {
+    try {
+      fs2.unlinkSync(tgz);
+    } catch {
+    }
+  }
+}
+function shortLine(b) {
+  const when = b.createdAt || b.queuedAt || "-";
+  return `${b.id}	${b.platform ?? "-"}	${b.profile ?? "-"}	${b.status}	${when}`;
+}
+function simulatorInstallHint(b) {
+  if (b.buildType !== "sim") return;
+  (0, import_core3.hint)(
+    "iOS simulator build (.app, unsigned). Download the artifact, then on a Mac:",
+    "  open -a Simulator                                   # boot a simulator",
+    `  tar -xzf <downloaded>.tar.gz && xcrun simctl install booted *.app`
+  );
+}
+async function waitUntilLaunched(id, maxMs = 45e3) {
+  const start = Date.now();
+  let b = (await (0, import_core3.getBuild)(id)).build;
+  while (b.status === "new" && Date.now() - start < maxMs) {
+    await sleep(2500);
+    b = (await (0, import_core3.getBuild)(id)).build;
+  }
+  return b;
+}
+async function watch(id, maxMs = 30 * 60 * 1e3) {
+  const start = Date.now();
+  let last = "";
+  while (true) {
+    const { build } = await (0, import_core3.getBuild)(id);
+    if (build.status !== last) {
+      (0, import_core3.info)(`  ${build.status}`);
+      last = build.status;
+    }
+    if ((0, import_core3.isTerminalStatus)(build.status)) return build;
+    if (Date.now() - start > maxMs) {
+      (0, import_core3.info)(`  (still ${build.status} after ${Math.round(maxMs / 6e4)}m \u2014 stopping watch)`);
+      return build;
+    }
+    await sleep(5e3);
+  }
+}
+function registerBuildCommands(program2) {
+  const build = program2.command("build").description("Native app builds (Android/iOS).");
+  build.command("list").description("List builds for an app (newest first).").option("--app <appId>", "app id (or tile.json / TILE_APP)").action(async (opts) => {
+    const app = (0, import_core3.resolveApp)(opts);
+    const builds = await (0, import_core3.listBuilds)(app);
+    if ((0, import_core3.isJsonMode)()) {
+      (0, import_core3.out)(builds);
+      return;
+    }
+    if (!builds.length) (0, import_core3.info)("No builds yet.");
+    else for (const b of builds) (0, import_core3.info)(shortLine(b));
+    (0, import_core3.hint)(`Next: \`tile build status <id>\` for details, or \`tile build create --platform android\`.`);
+  });
+  build.command("status <id>").description("Show a build\u2019s status, metadata, and (when finished) a download URL.").action(async (id) => {
+    const { build: b, artifactUrl } = await (0, import_core3.getBuild)(id);
+    if ((0, import_core3.isJsonMode)()) {
+      (0, import_core3.out)({ build: b, artifactUrl });
+      return;
+    }
+    (0, import_core3.info)(`${b.id}  ${b.platform ?? "-"}/${b.profile ?? "-"}  ${b.status}`);
+    if (b.versionName) (0, import_core3.info)(`  version: ${b.versionName}`);
+    if (b.error) (0, import_core3.info)(`  error: ${JSON.stringify(b.error)}`);
+    if (artifactUrl) (0, import_core3.info)(`  artifact: ${artifactUrl}`);
+    if (b.status === "finished" && artifactUrl) {
+      if (b.buildType === "sim") simulatorInstallHint(b);
+      else (0, import_core3.hint)("Next: download the artifact, or `tile ota deploy` (M2).");
+    } else if (!(0, import_core3.isTerminalStatus)(b.status)) (0, import_core3.hint)(`Next: \`tile build logs ${id}\` to tail, or \`tile build status ${id}\`.`);
+  });
+  build.command("logs <id>").description("Fetch build logs (use --after <seq> to page).").option("--after <seq>", "only logs after this sequence number", "0").action(async (id, opts) => {
+    const res = await (0, import_core3.getLogs)(id, parseInt(opts.after, 10) || 0);
+    (0, import_core3.out)(res);
+  });
+  build.command("cancel <id>").description("Cancel an in-progress build.").action(async (id) => {
+    const { build: b } = await (0, import_core3.cancelBuild)(id);
+    if ((0, import_core3.isJsonMode)()) (0, import_core3.out)(b);
+    else (0, import_core3.info)(`\u2713 Cancel requested \u2014 ${b.id} is now ${b.status}.`);
+  });
+  build.command("create").description("Create (and launch) a native build.").requiredOption("--platform <platform>", "android | ios").option("--profile <profile>", "build profile (e.g. production, preview)").option("--build-type <type>", "apk | aab | ipa").option("--source <source>", "upload (local files, default) | object | git | save", "upload").option("--source-object <key>", "pre-staged GCS object key (for --source object)").option("--ref <ref>", "git ref (for --source git)").option("--save <saveId>", "AppSave id to build (for --source save; omit = latest save)").option("--dir <dir>", "project dir to pack for --source upload", ".").option("--simulator", "iOS: build an unsigned simulator .app (no signing or registered device needed)").addOption(new import_commander.Option("--watch", "poll until the build reaches a terminal status").hideHelp(isAgentMode())).action(
+    async (opts) => {
+      const app = (0, import_core3.resolveApp)(opts);
+      if (opts.simulator && opts.platform !== "ios") {
+        throw new import_core3.TileError("--simulator is only valid with --platform ios.", import_core3.ExitCode.USAGE);
+      }
+      if (opts.platform === "ios" && !opts.simulator) {
+        (0, import_core3.hint)(
+          "iOS signing needs an App Store Connect API key. Set it (incl. team id) with:",
+          "  tile build credentials set-ios-key --file <AuthKey.p8> --key-id <id> --issuer-id <id> --team-id <id>",
+          "  (check current creds: `tile build credentials show`)",
+          "No signing? Build for the simulator instead: `tile build create --platform ios --simulator`."
+        );
+      } else if (opts.simulator) {
+        (0, import_core3.info)("Simulator build \u2014 unsigned .app, no signing credentials or registered device needed.");
+      }
+      if (opts.source === "object" && !opts.sourceObject) {
+        throw new import_core3.TileError("--source object requires --source-object <key>.", import_core3.ExitCode.USAGE);
+      }
+      if (opts.save && opts.source === "upload") opts.source = "save";
+      const { build: b, sourceUploadUrl } = await (0, import_core3.createBuild)(app, {
+        platform: opts.platform,
+        profile: opts.profile,
+        buildType: opts.buildType,
+        source: opts.source,
+        sourceObject: opts.sourceObject,
+        ref: opts.ref,
+        saveId: opts.save,
+        simulator: opts.simulator
+      });
+      if (opts.watch && isAgentMode()) {
+        (0, import_core3.info)(
+          "Note: `--watch` is not available in the Tile AI sandbox (it would block your turn). The build will be launched \u2014 track it from the dashboard, or tell the developer to run `tile build status <id>`."
+        );
+      }
+      const watching = !!opts.watch && !isAgentMode();
+      const follow = async (id) => {
+        if (!watching) {
+          (0, import_core3.info)("Launching\u2026");
+          const cur = await waitUntilLaunched(id);
+          if ((0, import_core3.isJsonMode)()) (0, import_core3.out)(cur);
+          else if (cur.status === "new")
+            (0, import_core3.info)(`Created ${id} \u2014 still queuing on the server. Check \`tile build status ${id}\`.`);
+          else (0, import_core3.info)(`\u2713 Launched ${id} (${b.platform}/${b.profile ?? "-"}) \u2014 status ${cur.status}.`);
+          (0, import_core3.hint)(`Next: \`tile build status ${id}\` (or re-run with --watch), \`tile build logs ${id}\`.`);
+          if ((0, import_core3.isTerminalStatus)(cur.status) && cur.status !== "finished") process.exitCode = import_core3.ExitCode.ERROR;
+          return;
+        }
+        (0, import_core3.info)(`Launching ${id} \u2014 watching\u2026`);
+        const final = await watch(id);
+        if ((0, import_core3.isJsonMode)()) (0, import_core3.out)(final);
+        else {
+          (0, import_core3.info)(`Build ${final.id} ended: ${final.status}.`);
+          if (final.status === "finished") simulatorInstallHint(final);
+        }
+        if (final.status !== "finished") process.exitCode = import_core3.ExitCode.ERROR;
+      };
+      if (sourceUploadUrl) {
+        const dir = path2.resolve(process.cwd(), opts.dir);
+        (0, import_core3.info)(`Packing ${dir} and uploading source\u2026`);
+        await packAndUpload(dir, sourceUploadUrl);
+        await (0, import_core3.startBuild)(b.id);
+        await follow(b.id);
+        return;
+      }
+      await follow(b.id);
+    }
+  );
+  const creds = build.command("credentials").alias("creds").description("Signing credentials (Android keystore, iOS ASC key).");
+  creds.command("show").description("Show the non-secret signing-credentials summary.").option("--app <appId>", "app id (or selected app)").action(async (opts) => {
+    const app = (0, import_core3.resolveApp)(opts);
+    const summary = await (0, import_core3.getCredentials)(app);
+    const play = await (0, import_core3.getPlayCredentials)(app).catch(() => ({ serviceAccount: null }));
+    (0, import_core3.out)({ ...summary, playServiceAccount: play.serviceAccount ?? null });
+    (0, import_core3.hint)(
+      "Set Android: `tile build credentials set-android-keystore --file <jks> \u2026`",
+      "Set iOS: `tile build credentials set-ios-key --file <p8> --key-id \u2026 --issuer-id \u2026 --team-id \u2026`",
+      "Change just the iOS team id (no re-upload): `tile build credentials set-ios-team-id <id>`",
+      "Set Google Play (Android submit): `tile build credentials set-play --file <service-account.json>`"
+    );
+  });
+  creds.command("set-android-keystore").description("Upload an Android keystore (becomes the default for builds).").requiredOption("--file <path>", "path to the .jks/.keystore file").requiredOption("--alias <alias>", "key alias").requiredOption("--store-password <pw>", "keystore password").option("--key-password <pw>", "key password (defaults to store password)").option("--app <appId>", "app id (or selected app)").action(async (opts) => {
+    const keystoreBase64 = fs2.readFileSync(opts.file).toString("base64");
+    const res = await (0, import_core3.uploadAndroidKeystore)((0, import_core3.resolveApp)(opts), {
+      keystoreBase64,
+      keyAlias: opts.alias,
+      storePassword: opts.storePassword,
+      keyPassword: opts.keyPassword
+    });
+    if ((0, import_core3.isJsonMode)()) (0, import_core3.out)(res);
+    else (0, import_core3.info)("\u2713 Android keystore uploaded.");
+  });
+  creds.command("rm-android-keystore").description("Remove the Android keystore (next build auto-generates one).").option("--app <appId>", "app id (or selected app)").option("-y, --yes", "skip confirmation").action(async (opts) => {
+    if (!opts.yes) throw new import_core3.TileError("Re-run with --yes to confirm.", import_core3.ExitCode.USAGE);
+    const res = await (0, import_core3.deleteAndroidKeystore)((0, import_core3.resolveApp)(opts));
+    if ((0, import_core3.isJsonMode)()) (0, import_core3.out)(res);
+    else (0, import_core3.info)("\u2713 Android keystore removed.");
+  });
+  creds.command("set-ios-key").description("Upload + verify an App Store Connect API key (.p8).").requiredOption("--file <path>", "path to the AuthKey_*.p8 file").requiredOption("--key-id <id>", "ASC key id").requiredOption("--issuer-id <id>", "ASC issuer id").option("--team-id <id>", "Apple Developer Team ID (e.g. ABCDE12345) \u2014 pins iOS signing; patch later with `set-ios-team-id`").option("--app <appId>", "app id (or selected app)").action(async (opts) => {
+    const p8Base64 = fs2.readFileSync(opts.file).toString("base64");
+    const res = await (0, import_core3.uploadIosAscKey)((0, import_core3.resolveApp)(opts), {
+      p8Base64,
+      keyId: opts.keyId,
+      issuerId: opts.issuerId,
+      teamId: opts.teamId
+    });
+    if ((0, import_core3.isJsonMode)()) (0, import_core3.out)(res);
+    else (0, import_core3.info)("\u2713 iOS ASC API key uploaded + verified.");
+  });
+  creds.command("set-ios-team-id <teamId>").description('Update ONLY the Apple Team ID on the existing ASC key (no .p8 re-upload). Pass "" to clear.').option("--app <appId>", "app id (or selected app)").action(async (teamId, opts) => {
+    const res = await (0, import_core3.setIosTeamId)((0, import_core3.resolveApp)(opts), teamId);
+    if ((0, import_core3.isJsonMode)()) (0, import_core3.out)(res);
+    else (0, import_core3.info)(teamId ? `\u2713 iOS team id set to ${teamId}.` : "\u2713 iOS team id cleared.");
+  });
+  creds.command("rm-ios-key").description("Remove the iOS ASC API key.").option("--app <appId>", "app id (or selected app)").option("-y, --yes", "skip confirmation").action(async (opts) => {
+    if (!opts.yes) throw new import_core3.TileError("Re-run with --yes to confirm.", import_core3.ExitCode.USAGE);
+    const res = await (0, import_core3.deleteIosAscKey)((0, import_core3.resolveApp)(opts));
+    if ((0, import_core3.isJsonMode)()) (0, import_core3.out)(res);
+    else (0, import_core3.info)("\u2713 iOS ASC API key removed.");
+  });
+  creds.command("set-play <file>").description("Upload a Google Play service-account JSON (required for Android store submit).").option("--app <appId>", "app id (or selected app)").action(async (file, opts) => {
+    const saJsonBase64 = fs2.readFileSync(file).toString("base64");
+    const res = await (0, import_core3.uploadPlayServiceAccount)((0, import_core3.resolveApp)(opts), { saJsonBase64 });
+    if ((0, import_core3.isJsonMode)()) (0, import_core3.out)(res);
+    else (0, import_core3.info)(res.valid ? `\u2713 Play service account uploaded: ${res.message}` : `Uploaded: ${res.message ?? ""}`);
+  });
+  creds.command("rm-play").description("Remove the Google Play service account.").option("--app <appId>", "app id (or selected app)").option("-y, --yes", "skip confirmation").action(async (opts) => {
+    if (!opts.yes) throw new import_core3.TileError("Re-run with --yes to confirm.", import_core3.ExitCode.USAGE);
+    const res = await (0, import_core3.deletePlayServiceAccount)((0, import_core3.resolveApp)(opts));
+    if ((0, import_core3.isJsonMode)()) (0, import_core3.out)(res);
+    else (0, import_core3.info)("\u2713 Play service account removed.");
+  });
+  const env = build.command("env").description("Per-app build environment variables.");
+  env.command("list").description("List environment variables (secret values omitted).").option("--app <appId>", "app id (or selected app)").action(async (opts) => {
+    const vars = await (0, import_core3.listEnvVars)((0, import_core3.resolveApp)(opts));
+    if ((0, import_core3.isJsonMode)()) {
+      (0, import_core3.out)(vars);
+      return;
+    }
+    if (!vars.length) (0, import_core3.info)("No env vars set.");
+    else for (const v of vars) (0, import_core3.info)(`${v.id}	${v.key}=${v.value ?? "(secret)"}	${(v.environments || []).join(",") || "all"}`);
+    (0, import_core3.hint)("Next: `tile build env set KEY=VALUE`.");
+  });
+  env.command("set <pair>").description("Create/update a variable (KEY=VALUE; upsert by key).").option("--visibility <v>", "plaintext | secret").option("--environments <list>", "comma-separated envs (e.g. preview,production)").option("--var-type <t>", "variable type").option("--app <appId>", "app id (or selected app)").action(async (pair, opts) => {
+    const i = pair.indexOf("=");
+    if (i < 0) throw new import_core3.TileError(`Bad pair "${pair}" \u2014 expected KEY=VALUE.`, import_core3.ExitCode.USAGE);
+    const res = await (0, import_core3.upsertEnvVar)((0, import_core3.resolveApp)(opts), {
+      key: pair.slice(0, i),
+      value: pair.slice(i + 1),
+      visibility: opts.visibility,
+      environments: opts.environments ? opts.environments.split(",").map((s) => s.trim()) : void 0,
+      varType: opts.varType
+    });
+    if ((0, import_core3.isJsonMode)()) (0, import_core3.out)(res);
+    else (0, import_core3.info)(`\u2713 Set ${pair.slice(0, i)}.`);
+  });
+  env.command("rm <id>").description("Delete an environment variable by id.").option("--app <appId>", "app id (or selected app)").action(async (id, opts) => {
+    await (0, import_core3.deleteEnvVar)((0, import_core3.resolveApp)(opts), id);
+    if ((0, import_core3.isJsonMode)()) (0, import_core3.out)({ ok: true, id });
+    else (0, import_core3.info)(`\u2713 Removed env var ${id}.`);
+  });
+  const versioning = build.command("versioning").description("Build-number / versionCode management.");
+  versioning.command("show").description("Show versioning settings for a platform.").option("--platform <platform>", "android | ios", "android").option("--app <appId>", "app id (or selected app)").action(async (opts) => {
+    (0, import_core3.out)(await (0, import_core3.getVersioning)((0, import_core3.resolveApp)(opts), opts.platform));
+  });
+  versioning.command("set").description("Set versioning source / versionCode / auto-increment.").option("--platform <platform>", "android | ios", "android").option("--source <source>", "manual | remote").option("--version-code <n>", "explicit version code").option("--auto-increment", "auto-increment the version code per build").option("--app <appId>", "app id (or selected app)").action(async (opts) => {
+    const res = await (0, import_core3.setVersioning)((0, import_core3.resolveApp)(opts), {
+      platform: opts.platform,
+      source: opts.source,
+      versionCode: opts.versionCode != null ? parseInt(opts.versionCode, 10) : void 0,
+      autoIncrement: opts.autoIncrement
+    });
+    if ((0, import_core3.isJsonMode)()) (0, import_core3.out)(res);
+    else (0, import_core3.info)("\u2713 Versioning updated.");
+  });
+  build.command("eas-config").description("Show build profiles from the repo\u2019s eas.json.").option("--app <appId>", "app id (or selected app)").action(async (opts) => {
+    (0, import_core3.out)(await (0, import_core3.getEasConfig)((0, import_core3.resolveApp)(opts)));
+  });
+  build.command("submit <buildId>").description("Submit a finished build to the store (iOS App Store/TestFlight, Android Play).").option("--mode <mode>", "upload | submit | both", "upload").option("--dest <dest>", "iOS destination: testflight | app-store").option("--track <track>", "Android track: internal | alpha | beta | production").option("--rollout <fraction>", "Android staged rollout fraction (0..1)").option("--no-wait", "return immediately (follow later with `tile build submissions logs <id>`)").action(
+    async (buildId, opts) => {
+      const mode = opts.mode === "both" ? "upload_and_submit" : opts.mode;
+      const { submission } = await (0, import_core3.submitBuild)(buildId, {
+        mode,
+        destination: opts.dest ?? opts.track,
+        rollout: opts.rollout != null ? parseFloat(opts.rollout) : void 0
+      });
+      (0, import_core3.info)(`Submission ${submission.id} \u2014 ${submission.platform} ${submission.mode} \u2192 ${submission.destination ?? "-"}`);
+      if (!opts.wait) {
+        if ((0, import_core3.isJsonMode)()) (0, import_core3.out)({ submission, waited: false });
+        else (0, import_core3.hint)(`Next: \`tile build submissions logs ${submission.id}\` to follow.`);
+        return;
+      }
+      const s = await followSubmission(submission.id);
+      const ok = s.status === "finished";
+      if ((0, import_core3.isJsonMode)()) (0, import_core3.out)({ ok, submission: s, error: ok ? null : s.error?.message ?? s.status });
+      else (0, import_core3.info)(ok ? "\u2713 submitted" : `\u2717 ${s.status} ${s.error?.message ?? ""}`);
+      if (!ok) process.exitCode = import_core3.ExitCode.ERROR;
+    }
+  );
+  const submissions = build.command("submissions").description("Inspect store submissions.");
+  submissions.command("list").description("List recent submissions (newest first).").option("--app <appId>", "app id (or selected app)").action(async (opts) => {
+    const subs = await (0, import_core3.listSubmissions)((0, import_core3.resolveApp)(opts));
+    if ((0, import_core3.isJsonMode)()) {
+      (0, import_core3.out)(subs);
+      return;
+    }
+    if (!subs.length) (0, import_core3.info)("No submissions yet.");
+    else for (const s of subs) (0, import_core3.info)(`${s.id}	${s.status}	${s.platform} ${s.mode} \u2192 ${s.destination ?? "-"}	${s.createdAt}`);
+  });
+  submissions.command("view <id>").description("Show one submission.").action(async (id) => {
+    const { submission: s } = await (0, import_core3.getSubmission)(id);
+    if ((0, import_core3.isJsonMode)()) {
+      (0, import_core3.out)(s);
+      return;
+    }
+    (0, import_core3.info)(`${s.id}  ${s.status}  ${s.platform} ${s.mode} \u2192 ${s.destination ?? "-"}`);
+    (0, import_core3.info)(`  build: ${s.buildId ?? "-"}  runner: ${s.runnerKind ?? "-"} ${s.runnerRef ?? ""}`);
+    if (s.error) (0, import_core3.info)(`  error: ${JSON.stringify(s.error)}`);
+  });
+  submissions.command("logs <id>").description("Stream a submission\u2019s logs until it finishes.").action(async (id) => {
+    const s = await followSubmission(id);
+    const ok = s.status === "finished";
+    if ((0, import_core3.isJsonMode)()) (0, import_core3.out)({ ok, submission: s });
+    else (0, import_core3.info)(s.status);
+    if (!ok) process.exitCode = import_core3.ExitCode.ERROR;
+  });
+  submissions.command("cancel <id>").description("Cancel a submission.").action(async (id) => {
+    const { submission } = await (0, import_core3.cancelSubmission)(id);
+    if ((0, import_core3.isJsonMode)()) (0, import_core3.out)(submission);
+    else (0, import_core3.info)(`submission ${id} \u2192 ${submission.status}`);
+  });
+  const devices = build.command("devices").description("iOS devices for ad-hoc distribution.");
+  devices.command("list").description("List iOS devices registered for ad-hoc builds.").option("--app <appId>", "app id (or selected app)").action(async (opts) => {
+    const list = await (0, import_core3.listDevices)((0, import_core3.resolveApp)(opts));
+    if ((0, import_core3.isJsonMode)()) {
+      (0, import_core3.out)(list);
+      return;
+    }
+    if (!list.length) (0, import_core3.info)("No devices registered \u2014 add one with `tile build devices create --udid <udid>`.");
+    else for (const d of list) (0, import_core3.info)(`${d.id}	${d.udid}	${d.status}	${d.name ?? ""}`);
+  });
+  devices.command("create").description("Register an iOS device UDID with Apple for ad-hoc builds.").requiredOption("--udid <udid>", "device UDID (from Finder/Xcode/Settings)").option("--name <name>", "a friendly name for the device").option("--app <appId>", "app id (or selected app)").action(async (opts) => {
+    const { device } = await (0, import_core3.createDevice)((0, import_core3.resolveApp)(opts), { udid: opts.udid, name: opts.name });
+    if ((0, import_core3.isJsonMode)()) (0, import_core3.out)(device);
+    else {
+      (0, import_core3.info)(`\u2713 registered ${device.udid}${device.name ? ` (${device.name})` : ""} (id ${device.id}).`);
+      (0, import_core3.hint)("It will be included in the next ad-hoc build\u2019s provisioning profile.");
+    }
+  });
+  devices.command("remove <id>").description("Disable a device with Apple and remove it.").option("--app <appId>", "app id (or selected app)").action(async (id, opts) => {
+    await (0, import_core3.removeDevice)((0, import_core3.resolveApp)(opts), id);
+    if ((0, import_core3.isJsonMode)()) (0, import_core3.out)({ ok: true, id });
+    else (0, import_core3.info)(`\u2713 removed device ${id}.`);
+  });
+  build.command("qr <id>").description("Render a scannable QR for a finished build\u2019s install link.").option("-o, --output <file>", "write the QR to an image file (.png or .svg) instead of the terminal").option("--small", "compact half-block QR (smaller, but harder for cameras to scan)").option("--url", "print only the install URL (no QR)").action(async (id, opts) => {
+    const { build: b, installUrl } = await (0, import_core3.getBuild)(id);
+    if (!installUrl) throw new import_core3.TileError(`No install link (status: ${b.status}).`, import_core3.ExitCode.ERROR);
+    if (opts.url) {
+      (0, import_core3.out)(installUrl);
+      return;
+    }
+    const rendered = await renderQr(installUrl, opts.output, { small: opts.small });
+    if ((0, import_core3.isJsonMode)()) {
+      (0, import_core3.out)({ installUrl, output: rendered.path ?? null });
+      return;
+    }
+    if (rendered.kind === "file") (0, import_core3.info)(`QR written \u2192 ${rendered.path}`);
+    else {
+      (0, import_core3.info)(rendered.text);
+      (0, import_core3.info)("hard to scan? shrink the terminal font so the whole QR fits, or use -o qr.png");
+    }
+    (0, import_core3.info)(`install: ${installUrl}`);
+    (0, import_core3.hint)("Scan with a device camera to download & install the build.");
+  });
+  build.command("download <id>").description("Download a finished build artifact to the current directory.").action(async (id) => {
+    const { build: b, artifactUrl } = await (0, import_core3.getBuild)(id);
+    if (!artifactUrl) throw new import_core3.TileError(`No artifact (status: ${b.status}).`, import_core3.ExitCode.ERROR);
+    const dest = await downloadArtifact(artifactUrl, b);
+    if ((0, import_core3.isJsonMode)()) (0, import_core3.out)({ ok: true, path: dest });
+    else {
+      (0, import_core3.info)(`\u2713 downloaded \u2192 ${dest}`);
+      if (b.buildType === "sim") (0, import_core3.hint)(`Run: tar -xzf ${b.id}.tar.gz && xcrun simctl install booted *.app`);
+    }
+  });
+  build.command("store-check <identifier>").description("Check whether a store app record exists (iOS bundle id / Android package).").option("--platform <p>", "ios | android", "ios").option("--app <appId>", "app id (or selected app)").action(async (identifier, opts) => {
+    const r = await (0, import_core3.storeAppCheck)((0, import_core3.resolveApp)(opts), opts.platform, identifier);
+    if (!r.reachable) throw new import_core3.TileError(`Could not reach the store API: ${r.message ?? ""}`, import_core3.ExitCode.NETWORK);
+    if (!r.exists) throw new import_core3.TileError(`No store app record for ${identifier}${r.message ? ` \u2014 ${r.message}` : ""}`, import_core3.ExitCode.NOT_FOUND);
+    if ((0, import_core3.isJsonMode)()) (0, import_core3.out)({ ...r, platform: opts.platform, identifier });
+    else (0, import_core3.info)(`\u2713 app exists: ${r.name ?? identifier}${r.appId ? ` (${r.appId})` : ""}`);
+  });
+}
+
+// src/commands/meta.ts
+var import_core4 = __toESM(require_dist());
+var GUIDE = `tile \u2014 one CLI for a Tile (Expo/React Native) app.
+
+Golden rules
+  \u2022 Discover commands with --help; never guess flags.
+  \u2022 Add --json to anything you parse (stdout = pure JSON, hints \u2192 stderr).
+  \u2022 Read exit codes: 0 ok \xB7 2 usage \xB7 3 auth \xB7 4 not found \xB7 5 conflict \xB7 6 backend down.
+  \u2022 Follow the "Next:" line each command prints.
+
+Setup
+  tile register              create a new account (email + password), then log in
+  tile login                 authenticate (or set TILE_TOKEN)
+  tile whoami                confirm the current user
+  tile app list              your apps;  tile use <appId>  selects the active one
+  tile status                where am I + the suggested next command
+
+Lifecycle (available today)
+  Apps          tile app create --name \u2026 \xB7 tile app list \xB7 tile use <appId> \xB7 tile app delete <id> -y
+  Local source  tile blueprints (list starters) \xB7 tile init \xB7 tile pull \xB7 tile save \xB7 tile saves \xB7 tile revert
+      \u25B8 \`tile init --name X\`                       \u2192 clones the \`default\` blueprint (Live Layer wired, appId injected)
+        \`tile init --name X --blueprint <id>\`      \u2192 clones a specific blueprint (see \`tile blueprints\`)
+        \`tile init --name X --bare\`                \u2192 a genuine BLANK Expo app (create-expo-app; no blueprint, no SDKs)
+      \u25B8 Use \`tile init\` (NOT just \`tile app create\`) when you intend to edit files and \`tile save\`.
+      \u25B8 History / undo: \`tile saves\` (newest first, * = current) \xB7 \`tile revert --to <saveId>\` re-saves an
+        older version as the new current (history preserved, itself revertable); then \`tile pull\` to sync local.
+  Native builds tile build
+      list \xB7 status <id> \xB7 logs <id> \xB7 cancel <id> \xB7 create --platform android|ios [--watch]
+      credentials (creds) show/set-android-keystore/set-ios-key \xB7 env list/set/rm \xB7 versioning show/set \xB7 eas-config
+  Testing       tile test  \u2014 e2e (Maestro) on a REAL emulator
+      (cloud) tile test run <buildId> --platform android   \u2192 triggers a run; prints a test id
+              tile test status <testId>                            \u2192 verdict (pass/fail) + what happened (lint/install/flows)
+              tile test list [<buildId>] [--platform android]   \xB7 tile test cancel <testId>
+      (local) tile test [--lint]  \u2014 run the flows in THIS environment (needs a device; not in the agent sandbox)
+  OTA / code-push tile ota \u2026  (forwards to tile-push)
+      ota deploy --platform android \xB7 ota bundle list \xB7 ota rollback <channel> \xB7 ota whoami
+  GitHub        tile github (alias gh)  \u2014 two-way sync with a repo
+      gh connect (browser OAuth) \xB7 gh status \xB7 gh repos \xB7 gh use <owner/repo> \xB7 gh disconnect
+      gh push   \u2192 mirror latest save to Git (Tile\u2192Git)
+      gh pull   \u2192 resync Git\u2192Tile (materialize branch HEAD into a save + write local; carries deps+assets;
+                  refuses a diverging pull without --force / last-writer-wins)
+      gh drift  \u2192 verify: has Git advanced past the latest cloud save? (in_sync / git_advanced / git_branch_gone)
+  Integrations  tile integrations (alias int)  \u2014 connect backends/services for the AI agent
+      int connect <supabase|shopify|custom> \xB7 int list \xB7 int disconnect <provider>
+      \u2192 credentials entered in the terminal, stored in Secret Manager (NEVER in chat);
+        the AI agent then uses connected integrations automatically (e.g. Supabase auth + DB).
+
+Note: \`tile save\` stores to Tile's DB+storage (source of truth). \`tile ota\` ships JS bundles
+over-the-air to installed apps (different thing). GitHub sync is two-way: \`gh push\` (Tile\u2192Git),
+\`gh pull\` (Git\u2192Tile), \`gh drift\` (verify). OTA auth is currently tile-push's own token.
+Coming later: unified OTA auth (one login)
+
+Run \`tile <group> --help\` for details. See AGENTS.md / SKILL.md for the full agent guide.`;
+function registerMetaCommands(program2) {
+  program2.command("guide").description("What Tile is + the lifecycle + how to use this CLI.").action(() => {
+    if ((0, import_core4.isJsonMode)()) {
+      (0, import_core4.out)({
+        summary: "tile \u2014 one CLI for a Tile (Expo/React Native) app.",
+        groups: {
+          auth: ["register", "login", "logout", "whoami"],
+          app: ["app create", "app list", "app get", "app delete", "use"],
+          source: ["blueprints", "init", "init --blueprint <id>", "init --bare", "pull", "save", "saves", "revert --to <saveId>"],
+          build: ["list", "status", "logs", "cancel", "create", "credentials", "env", "versioning", "eas-config"],
+          test: ["test run <id> --platform android", "test status <id>", "test list [<buildId>]", "test cancel <id>", "test --lint (local)"],
+          ota: ["ota deploy", "ota bundle list", "ota rollback", "ota whoami"],
+          github: ["github connect", "github status", "github repos", "github use", "github push", "github pull", "github drift", "github disconnect"],
+          integrations: ["integrations connect <supabase|shopify|custom>", "integrations list", "integrations disconnect <provider>"],
+          meta: ["guide", "status"]
+        },
+        exitCodes: { ok: 0, usage: 2, auth: 3, notFound: 4, conflict: 5, backendDown: 6 },
+        jsonContract: "add --json for machine output; stdout=JSON, hints=stderr",
+        notes: "tile save = store to Tile DB+storage (source of truth), NOT OTA code push",
+        comingSoon: ["unified OTA auth (one login for tile ota)"]
+      });
+    } else {
+      (0, import_core4.info)(GUIDE);
+    }
+  });
+  program2.command("status").description("Show current state (app/env, auth, recent builds) + next step.").option("--app <appId>", "override app id").option("--env <env>", "override environment").action(async (opts) => {
+    const appId = (0, import_core4.resolveAppOptional)(opts);
+    const env = (0, import_core4.resolveEnvOptional)(opts);
+    const hasToken = !!(0, import_core4.getToken)();
+    const state = {
+      appId: appId || null,
+      env: env || null,
+      authenticated: hasToken,
+      next: []
+    };
+    if (hasToken) {
+      try {
+        state.user = await (0, import_core4.whoami)();
+      } catch (e) {
+        state.authenticated = false;
+      }
+    }
+    if (appId && state.authenticated) {
+      try {
+        const builds = await (0, import_core4.listBuilds)(appId);
+        state.recentBuilds = builds.slice(0, 3).map((b) => ({ id: b.id, platform: b.platform, status: b.status }));
+      } catch (e) {
+        state.recentBuilds = { error: e.message };
+      }
+      try {
+        const tests = await (0, import_core4.listTests)(appId);
+        state.recentTests = tests.slice(0, 3).map((t) => ({ id: t.id, status: t.status, result: t.result ?? null, buildId: t.buildId ?? null }));
+      } catch (e) {
+        state.recentTests = { error: e.message };
+      }
+    }
+    if (!state.authenticated) state.next.push("tile login");
+    if (!appId) state.next.push("set TILE_APP / --app, or add appId to tile.json");
+    if (appId && !env) state.next.push("set TILE_ENV / --env (e.g. preview)");
+    if (state.authenticated && appId && env) {
+      state.next.push("tile build list --json");
+    }
+    if ((0, import_core4.isJsonMode)()) {
+      (0, import_core4.out)(state);
+      return;
+    }
+    (0, import_core4.info)(`App:    ${state.appId ?? "(none \u2014 set TILE_APP, --app, or tile.json)"}`);
+    (0, import_core4.info)(`Env:    ${state.env ?? "(none \u2014 set TILE_ENV or --env)"}`);
+    (0, import_core4.info)(`Auth:   ${state.authenticated ? `${state.user?.email ?? "yes"}` : "not authenticated"}`);
+    if (Array.isArray(state.recentBuilds)) {
+      if (state.recentBuilds.length) {
+        (0, import_core4.info)("Builds:");
+        for (const b of state.recentBuilds) (0, import_core4.info)(`  ${b.id}  ${b.platform ?? "-"}  ${b.status}`);
+      } else {
+        (0, import_core4.info)("Builds: none yet");
+      }
+    }
+    if (Array.isArray(state.recentTests)) {
+      if (state.recentTests.length) {
+        (0, import_core4.info)("Tests:");
+        for (const t of state.recentTests) {
+          const verdict = t.result ? t.result === "passed" ? "\u2713 passed" : "\u2717 failed" : t.status;
+          (0, import_core4.info)(`  ${t.id}  ${verdict}  (build ${t.buildId ?? "-"})`);
+        }
+      } else {
+        (0, import_core4.info)("Tests:  none yet");
+      }
+    }
+    (0, import_core4.hint)(`Next: ${state.next[0] ?? "tile status"}`);
+  });
+}
+
+// src/commands/app.ts
+var import_core5 = __toESM(require_dist());
+var path3 = __toESM(require("path"));
+function setActive(appId, name) {
+  const cfgPath = (0, import_core5.findConfigPath)();
+  if (cfgPath) {
+    const cfg = (0, import_core5.readConfig)();
+    cfg.appId = appId;
+    if (name) cfg.name = name;
+    (0, import_core5.linkProject)(appId, path3.dirname(cfgPath), name);
+    return (0, import_core5.writeConfig)(cfg);
+  }
+  return (0, import_core5.writeGlobalConfig)({ appId, ...name ? { name } : {} });
+}
+function registerAppCommands(program2) {
+  const app = program2.command("app").description("Create and manage Tile apps.");
+  app.command("create").description("Create a new Tile app and select it.").requiredOption("--name <name>", "app name").option("--blueprint <id>", "blueprint to seed from (default: default)").action(async (opts) => {
+    const res = await (0, import_core5.createApp)(opts.name, opts.blueprint);
+    const where = setActive(res.app.id, res.app.name);
+    if ((0, import_core5.isJsonMode)()) (0, import_core5.out)(res);
+    else (0, import_core5.info)(`\u2713 Created app ${res.app.id} ("${res.app.name}") \u2014 selected (${where}).`);
+    (0, import_core5.hint)(
+      `Next: \`tile pull\` to fetch its files. (To edit + \`tile save\`, \`tile init\` scaffolds locally in one step.)`
+    );
+  });
+  app.command("list").description("List your Tile apps.").action(async () => {
+    const apps = await (0, import_core5.listApps)();
+    if ((0, import_core5.isJsonMode)()) {
+      (0, import_core5.out)(apps);
+      return;
+    }
+    if (!apps.length) (0, import_core5.info)('No apps yet \u2014 `tile app create --name "My App"`.');
+    else for (const a of apps) (0, import_core5.info)(`${a.id}	${a.name}`);
+    (0, import_core5.hint)(`Next: \`tile use <appId>\` to select one.`);
+  });
+  app.command("get [id]").description("Show one app (defaults to the selected app).").action(async (id) => {
+    const appId = id || (0, import_core5.readConfig)().appId;
+    if (!appId) throw new import_core5.TileError("No app id given and none selected.", import_core5.ExitCode.USAGE, "Pass an id or run `tile use <appId>`.");
+    const a = await (0, import_core5.getApp)(appId);
+    (0, import_core5.out)(a);
+  });
+  app.command("delete <id>").description("Permanently delete an app and its files.").option("-y, --yes", "skip the confirmation prompt").action(async (id, opts) => {
+    if (!opts.yes) {
+      throw new import_core5.TileError(
+        `Refusing to delete ${id} without confirmation.`,
+        import_core5.ExitCode.USAGE,
+        "Re-run with --yes to confirm."
+      );
+    }
+    await (0, import_core5.deleteApp)(id);
+    if ((0, import_core5.isJsonMode)()) (0, import_core5.out)({ ok: true, id });
+    else (0, import_core5.info)(`\u2713 Deleted app ${id}.`);
+  });
+  program2.command("use <appId>").description("Select the active app (so build/push target it).").action(async (appId) => {
+    let name;
+    try {
+      const apps = await (0, import_core5.listApps)();
+      const match = apps.find((a) => a.id === appId);
+      if (!match) {
+        throw new import_core5.TileError(
+          `App ${appId} is not in your account.`,
+          import_core5.ExitCode.NOT_FOUND,
+          "Run `tile app list` to see your apps."
+        );
+      }
+      name = match.name;
+    } catch (e) {
+      if (e instanceof import_core5.TileError && e.exitCode === import_core5.ExitCode.NOT_FOUND) throw e;
+    }
+    const where = setActive(appId, name);
+    if ((0, import_core5.isJsonMode)()) (0, import_core5.out)({ appId, name, config: where });
+    else (0, import_core5.info)(`\u2713 Selected ${appId}${name ? ` ("${name}")` : ""} \u2014 saved to ${where}.`);
+    (0, import_core5.hint)(`Next: \`tile status\` to confirm.`);
+  });
+  program2.command("projects").alias("ls").description("List apps linked to a local repo on this machine.").action(async () => {
+    const reg = (0, import_core5.readProjectRegistry)();
+    const entries = Object.entries(reg).sort(
+      (a, b) => (b[1].lastUsedAt || "").localeCompare(a[1].lastUsedAt || "")
+    );
+    if ((0, import_core5.isJsonMode)()) {
+      (0, import_core5.out)(entries.map(([id, l]) => ({ appId: id, ...l })));
+      return;
+    }
+    if (!entries.length) {
+      (0, import_core5.info)("No linked projects yet \u2014 `tile init` or `tile pull` links one.");
+      return;
+    }
+    for (const [id, l] of entries) {
+      const exists = (0, import_core5.resolveProjectPath)(id) ? "" : "  (missing!)";
+      (0, import_core5.info)(`${id}	${l.name ?? ""}	${l.path}${exists}`);
+    }
+    (0, import_core5.hint)(`Next: \`tile save --app <id>\` works from anywhere \xB7 \`cd "$(tile path <id>)"\`.`);
+  });
+  program2.command("path <appId>").description("Print the local repo path linked to an app.").action(async (appId) => {
+    const p = (0, import_core5.resolveProjectPath)(appId);
+    if (!p) {
+      throw new import_core5.TileError(
+        `No local repo linked for ${appId} on this machine.`,
+        import_core5.ExitCode.NOT_FOUND,
+        `Run \`tile pull --app ${appId}\` to fetch it, or \`tile projects\` to see links.`
+      );
+    }
+    if ((0, import_core5.isJsonMode)()) (0, import_core5.out)({ appId, path: p });
+    else process.stdout.write(p + "\n");
+  });
+  program2.command("unlink <appId>").description("Forget an app\u2192repo link on this machine (leaves files + app untouched).").action(async (appId) => {
+    const removed = (0, import_core5.unlinkProject)(appId);
+    if ((0, import_core5.isJsonMode)()) (0, import_core5.out)({ appId, unlinked: removed });
+    else (0, import_core5.info)(removed ? `\u2713 Unlinked ${appId}.` : `No link for ${appId}.`);
+  });
+}
+
+// src/commands/source.ts
+var fs3 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
+var import_child_process2 = require("child_process");
+var import_core6 = __toESM(require_dist());
+var MANIFEST_DIR = ".tile";
+var MANIFEST_FILE = "manifest.json";
+var IGNORE = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".tile",
+  "dist",
+  ".expo",
+  "build",
+  "tile.json",
+  "TILE.md",
+  // Local OTA/deploy tooling — never round-trip into the saved app source.
+  ".env",
+  "tile-push.config.ts"
+]);
+function manifestPath(dir) {
+  return path4.join(dir, MANIFEST_DIR, MANIFEST_FILE);
+}
+function readLocalManifest(dir) {
+  try {
+    return JSON.parse(fs3.readFileSync(manifestPath(dir), "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeLocalManifest(dir, m) {
+  const p = manifestPath(dir);
+  fs3.mkdirSync(path4.dirname(p), { recursive: true });
+  fs3.writeFileSync(p, JSON.stringify(m, null, 2) + "\n");
+}
+function writeTree(dir, files, appId) {
+  const types = {};
+  for (const [rel, f] of Object.entries(files)) {
+    const dest = path4.join(dir, rel);
+    fs3.mkdirSync(path4.dirname(dest), { recursive: true });
+    if (f.type === "ASSET") fs3.writeFileSync(dest, Buffer.from(f.contents, "base64"));
+    else fs3.writeFileSync(dest, f.contents);
+    types[rel] = f.type;
+  }
+  writeLocalManifest(dir, { appId, types });
+  return Object.keys(files).length;
+}
+async function writeSaveToDir(appId, saveId, dir) {
+  const files = await (0, import_core6.getSaveFiles)(appId, saveId);
+  fs3.mkdirSync(dir, { recursive: true });
+  return writeTree(dir, files, appId);
+}
+function walk(dir, base = dir, acc = []) {
+  for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
+    if (IGNORE.has(entry.name)) continue;
+    const full = path4.join(dir, entry.name);
+    if (entry.isDirectory()) walk(full, base, acc);
+    else if (entry.isFile()) acc.push(path4.relative(base, full));
+  }
+  return acc;
+}
+var LIVE_LAYER_BASE = "https://storage.googleapis.com/tile-livelayer-configs";
+var WIRE_LIVE_LAYER = false;
+var SDK_NPM_VERSION = "^0.2.0";
+var OTA_API_URL = "https://ota.tile.dev";
+var TILE_PUSH_SDK_PKG = "@apptile/tile-push-react-native";
+var TILE_PUSH_SDK_VERSION = "^0.2.0";
+var TILE_PUSH_CLI_PKG = "@apptile/tile-push-cli";
+var TILE_PUSH_CLI_VERSION = "^0.1.0";
+var HOT_UPDATER_EXPO_PKG = "@hot-updater/expo";
+var HOT_UPDATER_EXPO_VERSION = "^0.32.0";
+var HOT_UPDATER_RN_PKG = "@hot-updater/react-native";
+var HOT_UPDATER_RN_VERSION = "^0.32.0";
+var HOT_UPDATER_CORE_PKG = "@hot-updater/core";
+var HOT_UPDATER_CORE_VERSION = "^0.32.0";
+var INJECT_OTA_RUNTIME = false;
+function wireProviders(dir, appId, env) {
+  const candidate = ["App.js", "App.tsx", "App.ts", "app/_layout.tsx"].find(
+    (f) => fs3.existsSync(path4.join(dir, f))
+  );
+  if (!candidate) return false;
+  const p = path4.join(dir, candidate);
+  let src = fs3.readFileSync(p, "utf8");
+  if (src.includes("LiveLayerProvider")) return true;
+  const marker = "export default function App";
+  if (!src.includes(marker)) return false;
+  src = src.replace(marker, "function BaseApp");
+  let imports = "";
+  if (WIRE_LIVE_LAYER) {
+    imports += `import { LiveLayerProvider } from 'tile-live-layer';
+import tileBootstrap from './assets/tile-live-layer.json';
+`;
+  }
+  if (INJECT_OTA_RUNTIME) imports += `import { TilePush } from '${TILE_PUSH_SDK_PKG}';
+`;
+  const liveLayerWrap = WIRE_LIVE_LAYER ? `
+
+// --- Auto-wired by \`tile init\`: Tile Live Layer (remote config). appId injected. ---
+// Read remote config anywhere below with the useLiveLayer hook (path, fallback):
+//   import { useLiveLayer } from 'tile-live-layer';
+//   const mode = useLiveLayer(['home', 'mode'], 'upcoming');
+// Change it remotely (no rebuild) with:  tile live-layer set home.mode=latest
+const tileLiveLayerOptions = {
+  appId: '${appId}',
+  env: '${env}',
+  baseUrl: '${LIVE_LAYER_BASE}',
+  bootstrap: tileBootstrap,
+  // context: [], // optional category, e.g. ['in','mumbai']; omit for the base layer
+};
+
+function TileApp(props) {
+  return (
+    <LiveLayerProvider options={tileLiveLayerOptions}>
+      <BaseApp {...props} />
+    </LiveLayerProvider>
+  );
+}
+` : `
+
+function TileApp(props) {
+  return (
+    <BaseApp {...props} />
+  );
+}
+`;
+  const otaWrap = INJECT_OTA_RUNTIME ? `
+// --- Auto-wired by \`tile init\`: Tile Push (OTA / code-push). Same appId. ---
+export default TilePush.wrap({
+  appId: '${appId}',
+  apiUrl: '${OTA_API_URL}',
+  updateStrategy: 'fingerprint',
+})(TileApp);
+` : `
+export default TileApp;
+// To enable OTA (code-push) once \`${TILE_PUSH_SDK_PKG}\` is installed, wrap the
+// default export \u2014 same appId as live-layer:
+//   import { TilePush } from '${TILE_PUSH_SDK_PKG}';
+//   export default TilePush.wrap({ appId: '${appId}', apiUrl: '${OTA_API_URL}', updateStrategy: 'fingerprint' })(TileApp);
+// Manage releases with \`tile ota --help\` (deploy / rollback / rollout / enable).
+`;
+  fs3.writeFileSync(p, imports + src + liveLayerWrap + otaWrap);
+  return true;
+}
+function peerBelowFloor(range) {
+  if (!range) return true;
+  const m = /(\d+)\.(\d+)/.exec(range);
+  if (!m) return false;
+  const major = Number(m[1]);
+  const minor = Number(m[2]);
+  if (major !== 0) return false;
+  return minor < 32;
+}
+function addSdkDependency(dir) {
+  const pkgPath = path4.join(dir, "package.json");
+  if (!fs3.existsSync(pkgPath)) return;
+  try {
+    const pkg = JSON.parse(fs3.readFileSync(pkgPath, "utf8"));
+    pkg.dependencies = pkg.dependencies || {};
+    let changed = false;
+    if (WIRE_LIVE_LAYER && !pkg.dependencies["tile-live-layer"]) {
+      pkg.dependencies["tile-live-layer"] = SDK_NPM_VERSION;
+      changed = true;
+    }
+    if (INJECT_OTA_RUNTIME) {
+      if (!pkg.dependencies[TILE_PUSH_SDK_PKG]) {
+        pkg.dependencies[TILE_PUSH_SDK_PKG] = TILE_PUSH_SDK_VERSION;
+        changed = true;
+      }
+      if (peerBelowFloor(pkg.dependencies[HOT_UPDATER_RN_PKG])) {
+        pkg.dependencies[HOT_UPDATER_RN_PKG] = HOT_UPDATER_RN_VERSION;
+        changed = true;
+      }
+      if (!pkg.dependencies[HOT_UPDATER_CORE_PKG]) {
+        pkg.dependencies[HOT_UPDATER_CORE_PKG] = HOT_UPDATER_CORE_VERSION;
+        changed = true;
+      }
+      pkg.devDependencies = pkg.devDependencies || {};
+      if (!pkg.devDependencies[TILE_PUSH_CLI_PKG] && !pkg.dependencies[TILE_PUSH_CLI_PKG]) {
+        pkg.devDependencies[TILE_PUSH_CLI_PKG] = TILE_PUSH_CLI_VERSION;
+        changed = true;
+      }
+      if (!pkg.devDependencies[HOT_UPDATER_EXPO_PKG] && !pkg.dependencies[HOT_UPDATER_EXPO_PKG]) {
+        pkg.devDependencies[HOT_UPDATER_EXPO_PKG] = HOT_UPDATER_EXPO_VERSION;
+        changed = true;
+      }
+    }
+    if (changed) fs3.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+  } catch {
+  }
+}
+function detectBundler(dir) {
+  try {
+    const pkg = JSON.parse(fs3.readFileSync(path4.join(dir, "package.json"), "utf8"));
+    const all = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (all.expo) return "expo";
+  } catch {
+  }
+  return "expo";
+}
+function wireTilePushConfig(dir, appId) {
+  const configPath = path4.join(dir, "tile-push.config.ts");
+  if (!fs3.existsSync(configPath)) {
+    const bundler = detectBundler(dir);
+    const buildImport = bundler === "expo" ? `import { expo } from '@hot-updater/expo';` : `import { metro } from '@hot-updater/metro';`;
+    const buildCall = bundler === "expo" ? `expo({ enableHermes: true })` : `metro()`;
+    fs3.writeFileSync(
+      configPath,
+      `// Auto-wired by \`tile init\`. OTA deploys target this app id (the same id as
+// live-layer and the Tile backend). Resolved from TILE_PUSH_APP_ID in .env.
+import 'dotenv/config';
+
+import { defineConfig } from 'hot-updater';
+${buildImport}
+import { tilePushDatabase, tilePushStorage } from '${TILE_PUSH_CLI_PKG}';
+
+const appId = process.env.TILE_PUSH_APP_ID;
+if (!appId) throw new Error('TILE_PUSH_APP_ID is not set (see .env).');
+
+export default defineConfig({
+  build: ${buildCall},
+  storage: tilePushStorage({ appId }),
+  database: tilePushDatabase({ appId }),
+  updateStrategy: 'fingerprint',
+});
+`
+    );
+  }
+  upsertEnvVar2(path4.join(dir, ".env"), "TILE_PUSH_APP_ID", appId);
+}
+function addAppJsonPlugin(dir) {
+  const appJsonPath = path4.join(dir, "app.json");
+  if (!fs3.existsSync(appJsonPath)) return;
+  try {
+    const appJson = JSON.parse(fs3.readFileSync(appJsonPath, "utf8"));
+    const expo = appJson.expo || (appJson.expo = {});
+    const plugins = Array.isArray(expo.plugins) ? expo.plugins : expo.plugins = [];
+    const already = plugins.some(
+      (p) => p === TILE_PUSH_SDK_PKG || Array.isArray(p) && p[0] === TILE_PUSH_SDK_PKG
+    );
+    if (already) return;
+    plugins.push(TILE_PUSH_SDK_PKG);
+    fs3.writeFileSync(appJsonPath, JSON.stringify(appJson, null, 2) + "\n");
+  } catch {
+  }
+}
+function regenerateLockfile(dir) {
+  if (!fs3.existsSync(path4.join(dir, "package.json"))) return false;
+  try {
+    const res = (0, import_child_process2.spawnSync)(
+      "npm",
+      ["install", "--package-lock-only", "--no-audit", "--no-fund"],
+      { cwd: dir, stdio: "ignore", env: process.env, timeout: 12e4 }
+    );
+    return res.status === 0;
+  } catch {
+    return false;
+  }
+}
+function upsertEnvVar2(envPath, key, value) {
+  let existing = "";
+  try {
+    existing = fs3.readFileSync(envPath, "utf8");
+  } catch {
+  }
+  const lines = existing ? existing.split("\n") : [];
+  const idx = lines.findIndex((l) => l.startsWith(`${key}=`));
+  if (idx >= 0) lines[idx] = `${key}=${value}`;
+  else {
+    if (existing && !existing.endsWith("\n")) lines.push("");
+    lines.push(`${key}=${value}`);
+  }
+  fs3.writeFileSync(envPath, lines.join("\n").replace(/\n*$/, "\n"));
+}
+var RUNTIME_PROVIDED_DEPS = /* @__PURE__ */ new Set([
+  "expo",
+  "react",
+  "react-native",
+  "react-dom",
+  "react-native-web",
+  "tailwindcss",
+  "nativewind",
+  "tailwind-merge",
+  "@expo/metro-runtime",
+  "react-native-worklets",
+  "react-native-worklets-core"
+]);
+function depsFromPackageJson(dir, prev) {
+  const pkgPath = path4.join(dir, "package.json");
+  let pkgDeps = {};
+  try {
+    pkgDeps = JSON.parse(fs3.readFileSync(pkgPath, "utf8")).dependencies || {};
+  } catch {
+    return prev ?? {};
+  }
+  const out12 = {};
+  for (const [name, versionRaw] of Object.entries(pkgDeps)) {
+    if (RUNTIME_PROVIDED_DEPS.has(name)) continue;
+    let version = String(versionRaw);
+    if (version.startsWith("file:") || version.startsWith("link:") || version.startsWith("workspace:")) version = "*";
+    const prevDep = prev?.[name];
+    out12[name] = prevDep && prevDep.version === version ? prevDep : { version };
+  }
+  return out12;
+}
+var FOUNDATIONAL_EXPO = [
+  "expo-modules-core",
+  "expo-asset",
+  "expo-font",
+  "expo-constants",
+  "expo-file-system",
+  "expo-keep-awake",
+  "expo-application",
+  "expo-device",
+  "expo-splash-screen",
+  "expo-status-bar",
+  "expo-linking",
+  "expo-updates",
+  "expo-manifests",
+  "expo-eas-client",
+  "expo-json-utils",
+  "expo-structured-headers"
+];
+var isExpoManaged = (n) => n === "expo" || n.startsWith("expo-") || n.startsWith("@expo/");
+function loadSdkChart(dir) {
+  const candidates = [
+    process.env.EXPO_SDK_CHART,
+    "/agent/sdk54-native-modules.json",
+    path4.join(dir, "node_modules/expo/bundledNativeModules.json")
+  ].filter(Boolean);
+  for (const p of candidates) {
+    try {
+      if (fs3.existsSync(p)) return JSON.parse(fs3.readFileSync(p, "utf8"));
+    } catch {
+    }
+  }
+  return null;
+}
+function normalizeExpoSdk(dir) {
+  const pkgPath = path4.join(dir, "package.json");
+  let text;
+  try {
+    text = fs3.readFileSync(pkgPath, "utf8");
+  } catch {
+    return;
+  }
+  const chart = loadSdkChart(dir);
+  if (!chart) return;
+  let pkg;
+  try {
+    pkg = JSON.parse(text);
+  } catch {
+    return;
+  }
+  const changes = [];
+  for (const field of ["dependencies", "devDependencies"]) {
+    const deps = pkg[field];
+    if (!deps || typeof deps !== "object") continue;
+    for (const name of Object.keys(deps)) {
+      if (chart[name] && deps[name] !== chart[name]) {
+        changes.push(`${name} ${deps[name]}\u2192${chart[name]}`);
+        deps[name] = chart[name];
+      }
+    }
+  }
+  const declaredExpo = ["dependencies", "devDependencies"].flatMap((f) => Object.keys(pkg[f] || {})).filter(isExpoManaged);
+  const overrides = pkg.overrides && typeof pkg.overrides === "object" ? pkg.overrides : {};
+  for (const name of /* @__PURE__ */ new Set([...FOUNDATIONAL_EXPO, ...declaredExpo])) {
+    if (chart[name] && overrides[name] !== chart[name]) {
+      changes.push(`override ${name}=${chart[name]}`);
+      overrides[name] = chart[name];
+    }
+  }
+  if (Object.keys(overrides).length) {
+    pkg.overrides = Object.fromEntries(Object.keys(overrides).sort().map((k) => [k, overrides[k]]));
+  }
+  if (!changes.length) return;
+  const nl = text.endsWith("\n") ? "\n" : "";
+  fs3.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + nl);
+  (0, import_core6.info)(`\u2713 Expo SDK lock: pinned ${changes.length} dep(s) to the supported SDK before save.`);
+}
+var BARE_APP_SOURCE = `import { StyleSheet, Text, View } from 'react-native';
+
+export default function App() {
+  return (
+    <View style={styles.container}>
+      <Text style={styles.title}>Hello from a blank Tile app \u{1F44B}</Text>
+      <Text style={styles.body}>Edit App.js and \`tile save\` to publish.</Text>
+    </View>
+  );
+}
+
+const styles = StyleSheet.create({
+  container: { flex: 1, backgroundColor: '#0b1020', alignItems: 'center', justifyContent: 'center', padding: 24 },
+  title: { fontSize: 22, fontWeight: '700', color: '#fff', marginBottom: 10 },
+  body: { fontSize: 15, color: '#9fb3c8', textAlign: 'center' },
+});
+`;
+function makeWebReady(dir) {
+  const indexJs = path4.join(dir, "index.js");
+  if (fs3.existsSync(indexJs)) fs3.rmSync(indexJs);
+  const pkgPath = path4.join(dir, "package.json");
+  if (fs3.existsSync(pkgPath)) {
+    const pkg = JSON.parse(fs3.readFileSync(pkgPath, "utf8"));
+    pkg.main = "node_modules/expo/AppEntry.js";
+    pkg.dependencies = {
+      ...pkg.dependencies || {},
+      expo: "~54.0.25",
+      react: "19.1.0",
+      "react-dom": "19.1.0",
+      "react-native": "0.81.5",
+      "react-native-web": "~0.21.0"
+    };
+    delete pkg.dependencies["expo-status-bar"];
+    fs3.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+  }
+  const appTsx = path4.join(dir, "App.tsx");
+  const appFile = fs3.existsSync(appTsx) ? appTsx : path4.join(dir, "App.js");
+  fs3.writeFileSync(appFile, BARE_APP_SOURCE);
+}
+function runBareExpo(dir) {
+  const parent = path4.dirname(dir);
+  const name = path4.basename(dir);
+  fs3.mkdirSync(parent, { recursive: true });
+  const r = (0, import_child_process2.spawnSync)(
+    "npx",
+    ["--yes", "create-expo-app@latest", name, "--template", "blank", "--no-install"],
+    { cwd: parent, stdio: "inherit" }
+  );
+  if (r.status !== 0) return false;
+  makeWebReady(dir);
+  return true;
+}
+var ASSET_EXT = /\.(png|jpe?g|gif|webp|avif|ico|bmp|tiff?|ttf|otf|woff2?|eot|mp4|mov|webm|mp3|wav|ogg|m4a|aac|flac|pdf|zip|gz|bin|wasm|jks|keystore|p8|p12|mobileprovision)$/i;
+function readFileEntry(dir, rel) {
+  const type = ASSET_EXT.test(rel) ? "ASSET" : "CODE";
+  const abs = path4.join(dir, rel);
+  const contents = type === "ASSET" ? fs3.readFileSync(abs).toString("base64") : fs3.readFileSync(abs, "utf8");
+  return { contents, type };
+}
+function buildFileMap(dir) {
+  const manifest = readLocalManifest(dir);
+  const types = manifest.types || {};
+  const map = {};
+  for (const rel of walk(dir)) {
+    const type = ASSET_EXT.test(rel) || types[rel] === "ASSET" ? "ASSET" : "CODE";
+    const contents = type === "ASSET" ? fs3.readFileSync(path4.join(dir, rel)).toString("base64") : fs3.readFileSync(path4.join(dir, rel), "utf8");
+    map[rel] = { contents, type };
+  }
+  return map;
+}
+function registerSourceCommands(program2) {
+  program2.command("pull").description("Fetch the app\u2019s current files into a local directory.").option("--app <appId>", "app id (or selected app)").option("--out <dir>", "output directory", ".").action(async (opts) => {
+    const appId = (0, import_core6.resolveApp)(opts);
+    const files = await (0, import_core6.getCurrentFiles)(appId);
+    const dir = path4.resolve(process.cwd(), opts.out);
+    fs3.mkdirSync(dir, { recursive: true });
+    const n = writeTree(dir, files, appId);
+    (0, import_core6.linkProject)(appId, dir);
+    if ((0, import_core6.isJsonMode)()) (0, import_core6.out)({ appId, files: n, dir });
+    else (0, import_core6.info)(`\u2713 Pulled ${n} file(s) for ${appId} \u2192 ${opts.out}`);
+    (0, import_core6.hint)(`Next: edit files, then \`tile save\` to store a new version.`);
+  });
+  program2.command("init").description("Create a new Tile app + scaffold it locally (from a blueprint, or --bare Expo).").requiredOption("--name <name>", "app name").option("--dir <dir>", "target directory (default: ./<name>)").option("--blueprint <id>", "blueprint to clone (see `tile blueprints`)", "default").option("--bare", "scaffold a genuine BLANK Expo app instead (create-expo-app; no Tile blueprint, no SDKs)").action(async (opts) => {
+    const env = "preview";
+    const dir = path4.resolve(process.cwd(), opts.dir || opts.name);
+    if (opts.bare) {
+      const res2 = await (0, import_core6.createApp)(opts.name);
+      const appId2 = res2.app.id;
+      (0, import_core6.info)("Scaffolding a blank Expo app (create-expo-app)\u2026");
+      const ok = runBareExpo(dir);
+      if (!ok) {
+        throw new import_core6.TileError(
+          "create-expo-app failed (needs network + npx).",
+          import_core6.ExitCode.ERROR,
+          "Retry, or use `tile init` (blueprint) instead of --bare."
+        );
+      }
+      (0, import_core6.writeConfig)({ appId: appId2, name: res2.app.name, env }, dir);
+      if (!(0, import_core6.findConfigPath)(dir)) (0, import_core6.writeGlobalConfig)({ appId: appId2, name: res2.app.name });
+      (0, import_core6.linkProject)(appId2, dir, res2.app.name);
+      fs3.writeFileSync(
+        path4.join(dir, "TILE.md"),
+        `# ${res2.app.name}
+
+Tile app \`${appId2}\` (env \`${env}\`) \u2014 **blank Expo app** (no Tile SDKs).
+
+This is a genuine create-expo-app blank project. Start from a batteries-included blueprint
+(\`tile blueprints\` \u2192 \`tile init --blueprint <id>\`) for a ready-made setup.
+
+> Note: the app's saved source on Tile is the seeded default blueprint until you run \`tile save\` to push this blank tree.
+
+## Workflow
+- Save edits: \`tile save\`
+- Build: \`tile build create --platform android\`
+`
+      );
+      if ((0, import_core6.isJsonMode)()) (0, import_core6.out)({ app: res2.app, dir, bare: true });
+      else {
+        (0, import_core6.info)(`\u2713 Created ${appId2} ("${res2.app.name}") + blank Expo app \u2192 ${dir}`);
+        (0, import_core6.info)("  \u21B3 Bare Expo (no Tile blueprint, no SDKs). `tile save` to push this tree as the app source.");
+      }
+      (0, import_core6.hint)(`Next: cd ${opts.dir || opts.name}, \`npm install\`, edit, then \`tile save\`.`);
+      return;
+    }
+    const res = await (0, import_core6.createApp)(opts.name, opts.blueprint);
+    const appId = res.app.id;
+    fs3.mkdirSync(dir, { recursive: true });
+    const files = await (0, import_core6.getFiles)(appId);
+    const n = writeTree(dir, files, appId);
+    (0, import_core6.writeConfig)({ appId, name: res.app.name, env }, dir);
+    if (!(0, import_core6.findConfigPath)(dir)) (0, import_core6.writeGlobalConfig)({ appId, name: res.app.name });
+    (0, import_core6.linkProject)(appId, dir, res.app.name);
+    if (WIRE_LIVE_LAYER) {
+      const assets = path4.join(dir, "assets");
+      fs3.mkdirSync(assets, { recursive: true });
+      fs3.writeFileSync(path4.join(assets, "tile-live-layer.json"), "{}\n");
+    }
+    const wired = wireProviders(dir, appId, env);
+    addSdkDependency(dir);
+    addAppJsonPlugin(dir);
+    wireTilePushConfig(dir, appId);
+    const lockOk = regenerateLockfile(dir);
+    fs3.writeFileSync(
+      path4.join(dir, "TILE.md"),
+      `# ${res.app.name}
+
+Tile app \`${appId}\` (env \`${env}\`) \u2014 blueprint \`${opts.blueprint}\`.
+
+> One id everywhere: \`${appId}\` is this app's id for source/saves, builds, AND OTA (tile-push).
+
+` + (WIRE_LIVE_LAYER ? `## Tile Live Layer (remote config)
+` + (wired ? `\`App\` is wrapped in \`<LiveLayerProvider>\` with this app's id already injected.
+Read flags with \`useLiveFlag('key', default)\` from \`tile-live-layer\`.
+` : `Could not auto-wrap the root \u2014 wrap it manually in \`<LiveLayerProvider config={{ appId: "${appId}", env: "${env}", baseUrl: "${LIVE_LAYER_BASE}" }}>\`.
+`) + `
+> \`tile-live-layer\` (${SDK_NPM_VERSION}) is added to package.json \u2014 run \`npm install\`.
+
+` : ``) + `## Code push (OTA) \u2014 tile-push
+OTA targets the SAME app id (\`${appId}\`), authenticated with your \`tile login\` session; the
+tenant is auto-provisioned on first deploy. Releases are managed via:
+
+- \`tile ota deploy --platform android --rollout 10\` \u2014 ship to 10% of devices
+- \`tile ota bundle list\` \u2014 see what's live \xB7 \`tile ota rollback production\` \u2014 pull latest
+- \`tile ota enable <id>\` / \`tile ota disable <id>\` \u2014 flip a bundle
+- \`tile ota --help\` \u2014 discover every command
+
+` + (INJECT_OTA_RUNTIME ? `The root is wrapped with \`TilePush.wrap(...)\` so devices auto-update on launch.
+` : `> To make devices auto-update: install \`${TILE_PUSH_SDK_PKG}\` and wrap the default export (snippet in \`App\`).
+`) + `
+## Workflow
+- Save edits: \`tile save\`
+- Build: \`tile build create --platform android\`
+- Ship JS-only update: \`tile ota deploy\`
+`
+    );
+    if ((0, import_core6.isJsonMode)())
+      (0, import_core6.out)({ app: res.app, dir, files: n, blueprint: opts.blueprint, liveLayerWired: wired, otaAppId: appId });
+    else {
+      (0, import_core6.info)(`\u2713 Created ${appId} ("${res.app.name}") from blueprint \`${opts.blueprint}\` \u2014 ${n} file(s) \u2192 ${dir}`);
+      (0, import_core6.info)(
+        wired ? `  \u21B3 Live Layer + Tile Push OTA wired into App (appId injected).` : `  \u21B3 Could not auto-wrap App \u2014 see TILE.md for the manual snippet.`
+      );
+      (0, import_core6.info)(`  \u21B3 OTA wired to the same id (${appId}) \u2014 SDK + config plugin + tile-push.config.ts written.`);
+      (0, import_core6.info)(
+        lockOk ? `  \u21B3 package-lock.json reconciled \u2014 \`npm ci\` and \`npm install\` both work.` : `  \u21B3 Could not refresh package-lock.json \u2014 run \`npm install\` before building.`
+      );
+      (0, import_core6.hint)(`  \u21B3 Run \`npm install\`, then \`tile build create --platform android\`.`);
+    }
+    (0, import_core6.hint)(`Next: cd ${opts.dir || opts.name}, edit, then \`tile save\`. See TILE.md.`);
+  });
+  program2.command("blueprints").description("List the available starter blueprints (for `tile init --blueprint <id>`).").action(async () => {
+    const bps = await (0, import_core6.listBlueprints)();
+    if ((0, import_core6.isJsonMode)()) {
+      (0, import_core6.out)(bps);
+      return;
+    }
+    if (!bps.length) (0, import_core6.info)("No blueprints available.");
+    else for (const b of bps) (0, import_core6.info)(`${b.id}	${b.emoji ?? ""} ${b.name}${b.description ? ` \u2014 ${b.description}` : ""}`);
+    (0, import_core6.hint)("Next: `tile init --name <name> --blueprint <id>` (or `--bare` for a blank Expo app).");
+  });
+  program2.command("save").description("Save the local files as a new version of the app (Tile DB + storage).").option("--app <appId>", "app id (or selected app / tile.json)").option("--dir <dir>", "project directory", ".").option("--branch <branch>", "branch to attach the save to").action(async (opts) => {
+    const dir = opts.dir !== "." || (0, import_core6.findConfigPath)() ? path4.resolve(process.cwd(), opts.dir) : (0, import_core6.resolveProjectDir)(opts);
+    const localAppId = readLocalManifest(dir).appId || (0, import_core6.readConfig)(dir).appId;
+    const appId = opts.app || localAppId || (0, import_core6.resolveApp)(opts);
+    (0, import_core6.linkProject)(appId, dir);
+    normalizeExpoSdk(dir);
+    const files = buildFileMap(dir);
+    if (!Object.keys(files).length) {
+      throw new import_core6.TileError(`No files found under ${opts.dir}.`, import_core6.ExitCode.USAGE, "Run `tile pull` or `tile init` first.");
+    }
+    const meta = await (0, import_core6.getLatestSaveMeta)(appId);
+    const res = await (0, import_core6.pushSave)(appId, {
+      files,
+      // Derive deps from the local package.json (not just the previous save's
+      // deps) so newly-added packages like tile-live-layer actually persist.
+      dependencies: depsFromPackageJson(dir, meta?.dependencies),
+      sdkVersion: meta?.sdkVersion,
+      branch: opts.branch ?? null
+    });
+    if ((0, import_core6.isJsonMode)()) (0, import_core6.out)(res);
+    else (0, import_core6.info)(`\u2713 Saved version ${res.saveId} (${Object.keys(files).length} files).`);
+    (0, import_core6.hint)(`Next: \`tile build create --platform android\` to build this version.`);
+  });
+  program2.command("saves").description("List saved versions (newest first). The current version is marked `*`.").option("--app <appId>", "app id (or selected app / tile.json)").option("--limit <n>", "max versions to show", "20").action(async (opts) => {
+    const dir = process.cwd();
+    const appId = opts.app || readLocalManifest(dir).appId || (0, import_core6.readConfig)(dir).appId || (0, import_core6.resolveApp)(opts);
+    const ids = await (0, import_core6.listSaves)(appId);
+    const limit = Math.max(1, Number.parseInt(opts.limit, 10) || 20);
+    const slice = ids.slice(0, limit);
+    const manifests = await Promise.all(slice.map((id) => (0, import_core6.getSaveManifest)(appId, id).catch(() => null)));
+    const rows = slice.map((id, i) => {
+      const m = manifests[i] || {};
+      return {
+        saveId: id,
+        current: i === 0,
+        timestamp: m.timestamp ?? null,
+        files: (m.files ?? []).length,
+        changed: (m.deltaFiles ?? []).length
+      };
+    });
+    if ((0, import_core6.isJsonMode)()) {
+      (0, import_core6.out)({ appId, total: ids.length, saves: rows });
+      return;
+    }
+    if (!rows.length) {
+      (0, import_core6.info)("No saves yet.");
+      (0, import_core6.hint)("Next: `tile save` to create the first version.");
+      return;
+    }
+    for (const r of rows) {
+      const when = r.timestamp ? r.timestamp.replace("T", " ").slice(0, 19) : "\u2014";
+      (0, import_core6.info)(`${r.current ? "*" : " "} ${r.saveId}  ${when}  ${r.files} files (${r.changed} changed)`);
+    }
+    if (ids.length > rows.length) (0, import_core6.info)(`  \u2026 ${ids.length - rows.length} older (use --limit ${ids.length}).`);
+    (0, import_core6.hint)("Next: `tile revert --to <saveId>` to restore a version.");
+  });
+  program2.command("revert").description("Revert the app to a previous save by re-saving its files as a new version (history is preserved).").option("--app <appId>", "app id (or selected app / tile.json)").requiredOption("--to <saveId>", "the save id to restore (see `tile saves`)").option("--branch <branch>", "branch to attach the new save to (default: the target save's branch)").action(async (opts) => {
+    const dir = process.cwd();
+    const appId = opts.app || readLocalManifest(dir).appId || (0, import_core6.readConfig)(dir).appId || (0, import_core6.resolveApp)(opts);
+    const ids = await (0, import_core6.listSaves)(appId);
+    if (!ids.length) {
+      throw new import_core6.TileError(`App ${appId} has no saves to revert to.`, import_core6.ExitCode.USAGE, "Run `tile save` first.");
+    }
+    if (!ids.includes(opts.to)) {
+      throw new import_core6.TileError(`Save ${opts.to} not found for app ${appId}.`, import_core6.ExitCode.USAGE, "Run `tile saves` to list valid ids.");
+    }
+    if (ids[0] === opts.to) {
+      throw new import_core6.TileError(`Save ${opts.to} is already the current version \u2014 nothing to revert.`, import_core6.ExitCode.USAGE);
+    }
+    const target2 = await (0, import_core6.getSaveManifest)(appId, opts.to);
+    const files = await (0, import_core6.getSaveFiles)(appId, opts.to);
+    if (!Object.keys(files).length) {
+      throw new import_core6.TileError(`Save ${opts.to} has no files.`, import_core6.ExitCode.ERROR);
+    }
+    const branch = opts.branch ?? (typeof target2?.branch === "string" ? target2.branch : null);
+    const res = await (0, import_core6.pushSave)(appId, {
+      files,
+      dependencies: target2?.dependencies,
+      sdkVersion: target2?.sdkVersion,
+      branch
+    });
+    const n = Object.keys(files).length;
+    if ((0, import_core6.isJsonMode)()) (0, import_core6.out)({ appId, revertedFrom: ids[0], revertedTo: opts.to, newSaveId: res.saveId, files: n });
+    else (0, import_core6.info)(`\u2713 Reverted to ${opts.to} \u2192 new version ${res.saveId} (${n} files).`);
+    (0, import_core6.hint)("Next: `tile pull` to sync your local copy, or `tile build create --platform android`.");
+  });
+}
+
+// src/commands/dev.ts
+var http = __toESM(require("http"));
+var fs5 = __toESM(require("fs"));
+var path6 = __toESM(require("path"));
+var crypto2 = __toESM(require("crypto"));
+
+// src/commands/devPhoneRelay.ts
+var os2 = __toESM(require("os"));
+var fs4 = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
+var crypto = __toESM(require("crypto"));
+var import_socket = require("socket.io");
+var ASSET_MIME = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".bmp": "image/bmp",
+  ".ico": "image/x-icon",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".mov": "video/quicktime",
+  ".m4v": "video/x-m4v",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".ogg": "audio/ogg",
+  ".m4a": "audio/mp4",
+  ".aac": "audio/aac",
+  ".flac": "audio/flac",
+  ".ttf": "font/ttf",
+  ".otf": "font/otf",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2"
+};
+var assetMime = (ext) => ASSET_MIME[ext.toLowerCase()] || "application/octet-stream";
+function getLanIp() {
+  const ifaces = os2.networkInterfaces();
+  for (const name of Object.keys(ifaces)) {
+    for (const ni of ifaces[name] ?? []) {
+      if (ni.family === "IPv4" && !ni.internal) return ni.address;
+    }
+  }
+  return null;
+}
+function readDependencies(dir) {
+  try {
+    const pkg = JSON.parse(fs4.readFileSync(path5.join(dir, "package.json"), "utf8"));
+    return pkg.dependencies && typeof pkg.dependencies === "object" ? pkg.dependencies : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function buildCodeMessage(fileMap, dependencies, assetCtx) {
+  const diff = {};
+  const s3url = {};
+  let skippedAssets = 0;
+  for (const [p, entry] of Object.entries(fileMap)) {
+    if (entry.type === "ASSET") {
+      if (assetCtx) {
+        const ext = path5.extname(p);
+        const hash = crypto.createHash("sha256").update(entry.contents).digest("hex").slice(0, 16);
+        const key = `${hash}${ext}`;
+        assetCtx.index.set(key, { contents: entry.contents, mime: assetMime(ext) });
+        diff[p] = "";
+        s3url[p] = `${assetCtx.baseUrl}/${key}`;
+      } else {
+        skippedAssets++;
+      }
+      continue;
+    }
+    diff[p] = entry.contents;
+  }
+  if (skippedAssets > 0) {
+    console.log(`  \u26A0 phone preview: skipped ${skippedAssets} asset(s) (no LAN address to host them)`);
+  }
+  return { type: "CODE", diff, s3url, ...dependencies ? { dependencies } : {} };
+}
+var fmtBytes = (n) => n < 1024 ? `${n}b` : `${(n / 1024).toFixed(1)}kb`;
+var ts = () => {
+  try {
+    return (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
+  } catch {
+    return "";
+  }
+};
+function attachPhoneRelay(server, dir, snapshot, opts = {}) {
+  const debug = !!opts.debug;
+  const dlog = (...m) => debug && console.log(`  [stream ${ts()}]`, ...m);
+  const io = new import_socket.Server(server, {
+    // CORS-open like the SSE endpoints; native clients don't enforce it but
+    // a browser-based run-engine (web player) would.
+    cors: { origin: "*" },
+    transports: ["websocket", "polling"],
+    // The device answers heartbeats on its JS thread, which can be busy for a
+    // few seconds during a heavy reload (large bundle transpile, full remount).
+    // Be generous so a legitimate busy spell doesn't get mistaken for a dead
+    // client and dropped — the run-engine also bounds its own fetches now.
+    pingTimeout: 6e4,
+    pingInterval: 25e3
+  });
+  const sockets = /* @__PURE__ */ new Set();
+  const assetIndex = /* @__PURE__ */ new Map();
+  const sendCodeTo = (socket) => {
+    const channel = socket.data.channel;
+    if (!channel) return;
+    const deps = readDependencies(dir);
+    const assetCtx = opts.assetBaseUrl ? { baseUrl: opts.assetBaseUrl, index: assetIndex } : void 0;
+    const msg = buildCodeMessage(snapshot(), deps, assetCtx);
+    socket.emit("message", { channel, message: msg, sender: "tiledev" });
+    if (debug) {
+      const files = Object.entries(msg.diff);
+      const total = files.reduce((s, [, c]) => s + Buffer.byteLength(c), 0);
+      const list = files.map(([p, c]) => `${p} ${fmtBytes(Buffer.byteLength(c))}`).join(", ");
+      dlog(
+        `\u2192 CODE  sid=${socket.id.slice(0, 6)}  files=${files.length}  deps=${deps ? Object.keys(deps).length : 0}  total=${fmtBytes(total)}
+             [${list}]`
+      );
+    }
+  };
+  io.on("connection", (socket) => {
+    sockets.add(socket);
+    dlog(`device connected  sid=${socket.id.slice(0, 6)}  addr=${socket.handshake.address}`);
+    socket.on("subscribeChannel", (data) => {
+      socket.data.channel = data.channel;
+      socket.join(data.channel);
+      console.log(`  \u{1F4F1} device subscribed (channel ${data.channel}, ${sockets.size} device(s))`);
+      dlog(`\u2190 subscribe  channel=${data.channel}  sender=${data.sender ?? "?"}`);
+      sendCodeTo(socket);
+    });
+    socket.on("unsubscribeChannel", (data) => {
+      if (data?.channel) socket.leave(data.channel);
+      dlog(`\u2190 unsubscribe  channel=${data?.channel}`);
+    });
+    socket.on("message", (data) => {
+      const m = data?.message ?? {};
+      const type = m.type;
+      if (type === "RESEND_CODE") {
+        dlog("\u2190 RESEND_CODE  (device asked for the latest code)");
+        sendCodeTo(socket);
+        return;
+      }
+      if (debug) {
+        if (type === "CONSOLE") {
+          const payload = Array.isArray(m.payload) ? m.payload.join(" ") : String(m.payload ?? "");
+          const tag = m.method === "error" ? "\u{1F534}" : m.method === "warn" ? "\u{1F7E1}" : "\u26AA";
+          dlog(`\u2190 ${tag} app.console.${m.method}:`, payload);
+        } else if (type === "STATUS_REPORT") {
+          dlog(`\u2190 STATUS_REPORT  status=${JSON.stringify(m.status)}`);
+        } else if (type === "DOM_DATA") {
+          dlog(`\u2190 DOM_DATA  (layers: ${m.data ? Object.keys(m.data).length : 0})`);
+        } else if (type) {
+          dlog(`\u2190 ${type}`);
+        }
+      }
+      if (data?.channel) socket.to(data.channel).emit("message", data);
+    });
+    socket.on("disconnect", (reason) => {
+      sockets.delete(socket);
+      dlog(`device disconnected  sid=${socket.id.slice(0, 6)}  reason=${reason}  (${sockets.size} left)`);
+    });
+  });
+  return {
+    broadcast() {
+      if (debug && sockets.size === 0) dlog("file changed but no devices connected \u2014 nothing to push");
+      for (const socket of sockets) sendCodeTo(socket);
+    },
+    deviceCount() {
+      return sockets.size;
+    },
+    serveAsset(key) {
+      return assetIndex.get(key);
+    }
+  };
+}
+
+// src/commands/dev.ts
+var PORT_DEFAULT = 7163;
+var DEV_CHANNEL = "tiledev";
+var sha1 = (s) => crypto2.createHash("sha1").update(s).digest("hex");
+function isIgnored(rel) {
+  if (/(^|[/\\])(node_modules|\.git|\.tile|dist|build|\.expo|\.next|coverage)([/\\]|$)/.test(rel)) return true;
+  if (/\.tmp\.\d+\.[0-9a-f]+$/i.test(rel)) return true;
+  return rel.split(/[/\\]/).some((seg) => seg.length > 1 && seg.startsWith("."));
+}
+function registerDevCommands(program2) {
+  program2.command("dev", { hidden: isAgentMode() }).description("Run a local Dev Mode server that streams file saves to the Tile dashboard.").option("--dir <dir>", "project directory", ".").option("--port <port>", "local server port", String(PORT_DEFAULT)).option("--debug", "verbose stream logging: every CODE push (files+sizes), device connects, and the app's own console.log/warn/error + crashes surfaced in this terminal").action(async (opts) => {
+    if (blockedInAgentMode(
+      "dev",
+      "Your edits already stream to the dashboard preview automatically \u2014 you don't need to watch or build. (Dev Mode / `tile dev` is for a human developer using their own IDE.)"
+    )) {
+      return;
+    }
+    const dir = path6.resolve(process.cwd(), opts.dir);
+    const port = parseInt(opts.port, 10) || PORT_DEFAULT;
+    const lanIp = getLanIp();
+    const assetBaseUrl = lanIp ? `http://${lanIp}:${port}/__tiledev/~asset` : void 0;
+    let phoneRelay;
+    let appId;
+    try {
+      appId = JSON.parse(fs5.readFileSync(path6.join(dir, ".tile", "manifest.json"), "utf8")).appId;
+    } catch {
+    }
+    const clients = /* @__PURE__ */ new Set();
+    const lastWritten = /* @__PURE__ */ new Map();
+    const readBody = (req) => new Promise((resolve7) => {
+      let b = "";
+      req.on("data", (c) => b += c);
+      req.on("end", () => resolve7(b));
+    });
+    const sendAll = (obj) => {
+      const line = `data: ${JSON.stringify(obj)}
+
+`;
+      for (const r of clients) {
+        try {
+          r.write(line);
+        } catch {
+        }
+      }
+    };
+    const server = http.createServer((req, res) => {
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Access-Control-Allow-Headers", "content-type");
+      res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
+      if (req.method === "OPTIONS") {
+        res.writeHead(204).end();
+        return;
+      }
+      if ((req.url || "").startsWith("/__tiledev/~asset/")) {
+        const key = (req.url || "").slice("/__tiledev/~asset/".length).split("?")[0];
+        const a = phoneRelay?.serveAsset(key);
+        if (!a) {
+          res.writeHead(404).end();
+          return;
+        }
+        const buf = Buffer.from(a.contents, "base64");
+        res.writeHead(200, { "content-type": a.mime, "content-length": String(buf.length) });
+        res.end(req.method === "HEAD" ? void 0 : buf);
+        return;
+      }
+      const url = new URL(req.url || "/", `http://localhost:${port}`);
+      if (url.pathname === "/__tiledev/hello" || url.pathname === "/check-dev-mode") {
+        res.writeHead(200, { "content-type": "application/json", "cache-control": "no-store" });
+        res.end(JSON.stringify({
+          ok: true,
+          server: "tile-cli-dev",
+          protocol: 1,
+          appId: appId ?? null,
+          dir,
+          files: Object.keys(buildFileMap(dir)).length,
+          // Scan-to-pair payload so the dashboard can render a "Connect preview"
+          // QR in Dev Mode: the preview app reads relay host + channel from this
+          // at runtime. Null when we couldn't determine a LAN IP (no phone path).
+          channel: DEV_CHANNEL,
+          pairUrl: lanIp ? `tiledev://${lanIp}:${port}?channel=${DEV_CHANNEL}` : null
+        }));
+        return;
+      }
+      if (url.pathname === "/__tiledev/events") {
+        res.writeHead(200, {
+          "content-type": "text/event-stream",
+          "cache-control": "no-cache",
+          connection: "keep-alive"
+        });
+        res.write("retry: 1000\n\n");
+        clients.add(res);
+        req.on("close", () => clients.delete(res));
+        try {
+          res.write(`data: ${JSON.stringify({ type: "snapshot", files: buildFileMap(dir) })}
+
+`);
+        } catch {
+        }
+        console.log(`  \u2713 dashboard connected (${clients.size} client${clients.size === 1 ? "" : "s"})`);
+        return;
+      }
+      if (url.pathname === "/__tiledev/write" && req.method === "POST") {
+        readBody(req).then((body) => {
+          let p;
+          try {
+            p = JSON.parse(body || "{}");
+          } catch {
+            res.writeHead(400).end("bad json");
+            return;
+          }
+          const rel = String(p.path || "");
+          const abs = path6.resolve(dir, rel);
+          if (!rel || rel.startsWith("/") || abs !== dir && !abs.startsWith(dir + path6.sep)) {
+            res.writeHead(400).end("bad path");
+            return;
+          }
+          try {
+            const contents = String(p.contents ?? "");
+            fs5.mkdirSync(path6.dirname(abs), { recursive: true });
+            if (p.type === "ASSET") fs5.writeFileSync(abs, Buffer.from(contents, "base64"));
+            else fs5.writeFileSync(abs, contents, "utf8");
+            lastWritten.set(rel, sha1(readFileEntry(dir, rel).contents));
+            console.log(`  \u2190 ${rel} (from design panel)`);
+            res.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify({ ok: true }));
+          } catch (e) {
+            res.writeHead(500).end(`write failed: ${e?.message || e}`);
+          }
+        });
+        return;
+      }
+      res.writeHead(404).end("not found");
+    });
+    phoneRelay = attachPhoneRelay(server, dir, () => buildFileMap(dir), { debug: !!opts.debug, assetBaseUrl });
+    let broadcastTimer = null;
+    const scheduleBroadcast = () => {
+      if (broadcastTimer) clearTimeout(broadcastTimer);
+      broadcastTimer = setTimeout(() => {
+        broadcastTimer = null;
+        phoneRelay.broadcast();
+      }, 150);
+    };
+    const pending = /* @__PURE__ */ new Map();
+    const onChange = (rel) => {
+      if (!rel || isIgnored(rel)) return;
+      const prev = pending.get(rel);
+      if (prev) clearTimeout(prev);
+      pending.set(rel, setTimeout(() => {
+        pending.delete(rel);
+        const abs = path6.join(dir, rel);
+        if (!fs5.existsSync(abs)) {
+          sendAll({ type: "unlink", path: rel });
+          scheduleBroadcast();
+          console.log(`  \u2717 ${rel} (deleted)`);
+          return;
+        }
+        try {
+          const stat = fs5.statSync(abs);
+          if (stat.isDirectory()) return;
+          const { contents, type } = readFileEntry(dir, rel);
+          if (lastWritten.get(rel) === sha1(contents)) {
+            lastWritten.delete(rel);
+            scheduleBroadcast();
+            console.log(`  \u2192 ${rel} (editor \u2192 preview)`);
+            return;
+          }
+          sendAll({ type: "edit", path: rel, contents, fileType: type });
+          scheduleBroadcast();
+          console.log(`  \u2192 ${rel}`);
+        } catch {
+        }
+      }, 80));
+    };
+    try {
+      fs5.watch(dir, { recursive: true }, (_event, filename) => {
+        if (filename) onChange(String(filename));
+      });
+    } catch {
+      console.error("\u26A0 recursive fs.watch is unavailable on this platform; nested-dir saves may not stream (macOS/Windows are fine).");
+    }
+    server.listen(port, async () => {
+      const link = `http://localhost:${port}`;
+      console.log(`\u25B8 tile dev \u2014 watching ${dir}${appId ? `  (app ${appId})` : ""}`);
+      console.log(`  Local dev server: ${link}`);
+      console.log('  In the Tile dashboard editor, click "Dev Mode" and paste that URL.');
+      console.log("  Then just save files in your IDE \u2014 the preview updates live. Ctrl-C to stop.");
+      if (lanIp) {
+        const relayUrl = `http://${lanIp}:${port}`;
+        const pairUrl = `tiledev://${lanIp}:${port}?channel=${DEV_CHANNEL}`;
+        console.log("");
+        console.log("  \u2500\u2500 \u{1F4F1} Phone preview (same WiFi) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+        console.log(`  Relay:   ${relayUrl}   (channel ${DEV_CHANNEL})`);
+        console.log("  Scan this QR in the preview app to connect:");
+        console.log(`  ${pairUrl}`);
+        try {
+          const qrt = require("qrcode-terminal");
+          await new Promise(
+            (resolve7) => qrt.generate(pairUrl, { small: true }, (s) => {
+              console.log("\n" + s);
+              resolve7();
+            })
+          );
+        } catch {
+        }
+        console.log(`  Or set env vars on a dev build: EXPO_PUBLIC_TILE_PACKET_PUB_URL=${relayUrl} EXPO_PUBLIC_TILE_DEV_CHANNEL=${DEV_CHANNEL}`);
+      } else {
+        console.log("  (no LAN IP found \u2014 phone preview unavailable on this network)");
+      }
+    });
+  });
+}
+
+// src/commands/preview.ts
+var http2 = __toESM(require("http"));
+var import_socket2 = require("socket.io");
+var PORT_DEFAULT2 = 4700;
+var CHANNEL = "tiledev";
+function registerPreviewCommands(program2) {
+  program2.command("preview", { hidden: isAgentMode() }).description("Relay-only live preview: the dashboard streams code straight to a device (no local files).").option("--port <port>", "local relay port", String(PORT_DEFAULT2)).action(async (opts) => {
+    if (blockedInAgentMode(
+      "preview",
+      "Your edits already stream to the dashboard preview automatically \u2014 `tile preview` is for a human pairing a phone to the dashboard."
+    )) {
+      return;
+    }
+    const port = parseInt(opts.port, 10) || PORT_DEFAULT2;
+    const lanIp = getLanIp();
+    let latestCode = { type: "CODE", diff: {}, s3url: {} };
+    let pushCount = 0;
+    const sockets = /* @__PURE__ */ new Set();
+    const sendCodeTo = (socket) => {
+      const channel = socket.data.channel;
+      if (channel) socket.emit("message", { channel, message: latestCode, sender: "tilepreview" });
+    };
+    const server = http2.createServer((req, res) => {
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Access-Control-Allow-Headers", "content-type");
+      res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+      if (req.method === "OPTIONS") {
+        res.writeHead(204).end();
+        return;
+      }
+      const url = new URL(req.url || "/", `http://localhost:${port}`);
+      if (url.pathname === "/__tiledev/hello") {
+        res.writeHead(200, { "content-type": "application/json", "cache-control": "no-store" });
+        res.end(JSON.stringify({
+          ok: true,
+          server: "tile-cli-preview",
+          protocol: 1,
+          channel: CHANNEL,
+          pairUrl: lanIp ? `tiledev://${lanIp}:${port}?channel=${CHANNEL}` : null,
+          devices: sockets.size
+        }));
+        return;
+      }
+      if (url.pathname === "/__tilepreview/push" && req.method === "POST") {
+        let body = "";
+        req.on("data", (c) => body += c);
+        req.on("end", () => {
+          try {
+            const parsed = JSON.parse(body || "{}");
+            latestCode = {
+              type: "CODE",
+              diff: parsed.diff && typeof parsed.diff === "object" ? parsed.diff : {},
+              s3url: parsed.s3url && typeof parsed.s3url === "object" ? parsed.s3url : {},
+              ...parsed.dependencies ? { dependencies: parsed.dependencies } : {}
+            };
+            pushCount++;
+            for (const s of sockets) sendCodeTo(s);
+            const n = Object.keys(latestCode.diff).length;
+            console.log(`  \u2192 push #${pushCount}: ${n} file(s) \u2192 ${sockets.size} device(s)`);
+            res.writeHead(200, { "content-type": "application/json" });
+            res.end(JSON.stringify({ ok: true, devices: sockets.size }));
+          } catch (e) {
+            res.writeHead(400, { "content-type": "application/json" });
+            res.end(JSON.stringify({ ok: false, error: String(e?.message || e) }));
+          }
+        });
+        return;
+      }
+      res.writeHead(404).end();
+    });
+    const io = new import_socket2.Server(server, {
+      cors: { origin: "*" },
+      transports: ["websocket", "polling"],
+      pingTimeout: 6e4,
+      pingInterval: 25e3
+    });
+    io.on("connection", (socket) => {
+      sockets.add(socket);
+      socket.on("subscribeChannel", (data) => {
+        socket.data.channel = data.channel;
+        socket.join(data.channel);
+        console.log(`  \u{1F4F1} device subscribed (channel ${data.channel}, ${sockets.size} device(s))`);
+        sendCodeTo(socket);
+      });
+      socket.on("unsubscribeChannel", (data) => {
+        if (data?.channel) socket.leave(data.channel);
+      });
+      socket.on("message", (data) => {
+        if (data?.message?.type === "RESEND_CODE") sendCodeTo(socket);
+      });
+      socket.on("disconnect", () => {
+        sockets.delete(socket);
+      });
+    });
+    server.listen(port, () => {
+      const relayUrl = lanIp ? `http://${lanIp}:${port}` : `http://localhost:${port}`;
+      console.log("\u25B8 tile preview \u2014 relay-only live preview (no local files)");
+      console.log(`  Relay: ${relayUrl}  (channel ${CHANNEL})`);
+      console.log(`  In the dashboard: open "Dev Preview" and paste  http://localhost:${port}`);
+      if (lanIp) {
+        const pairUrl = `tiledev://${lanIp}:${port}?channel=${CHANNEL}`;
+        console.log("  Or scan this QR in the preview app:");
+        console.log(`  ${pairUrl}`);
+        try {
+          const qrt = require("qrcode-terminal");
+          qrt.generate(pairUrl, { small: true }, (s) => console.log("\n" + s));
+        } catch {
+        }
+      }
+      console.log("  Ctrl-C to stop.");
+    });
+  });
+}
+
+// src/commands/ota.ts
+var fs6 = __toESM(require("fs"));
+var path7 = __toESM(require("path"));
+var import_child_process3 = require("child_process");
+var import_core7 = __toESM(require_dist());
+var TILE_PUSH_CLI_PKG2 = "@apptile/tile-push-cli";
+var TILE_PUSH_CLI_VERSION2 = "0.1.0";
+function resolveTilePush(dir) {
+  const projectBin = path7.join(dir, "node_modules", ".bin", "tile-push");
+  if (fs6.existsSync(projectBin)) return { cmd: projectBin, prefix: [] };
+  const devBin = process.env.TILE_PUSH_CLI_BIN;
+  if (devBin && fs6.existsSync(devBin)) return { cmd: process.execPath, prefix: [devBin] };
+  return { cmd: "npx", prefix: ["-y", `${TILE_PUSH_CLI_PKG2}@${TILE_PUSH_CLI_VERSION2}`] };
+}
+var ALIASES = {
+  enable: ["bundle", "enable"],
+  disable: ["bundle", "disable"],
+  promote: ["bundle", "promote"]
+};
+function rewriteAlias(args) {
+  const [first, ...rest] = args;
+  const mapped = first && ALIASES[first];
+  return mapped ? [...mapped, ...rest] : args;
+}
+function runOta(args) {
+  const dir = process.cwd();
+  const { cmd, prefix } = resolveTilePush(dir);
+  const env = { ...process.env };
+  if (!env.TILE_PUSH_APP_ID) {
+    const selected = (0, import_core7.resolveAppOptional)();
+    if (selected) env.TILE_PUSH_APP_ID = selected;
+  }
+  if (env.TILE_PUSH_APP_ID && !env.TILE_PUSH_TOKEN) {
+    const token = (0, import_core7.getToken)();
+    if (token) env.TILE_PUSH_TOKEN = token;
+  }
+  const result = (0, import_child_process3.spawnSync)(cmd, [...prefix, ...rewriteAlias(args)], {
+    cwd: dir,
+    stdio: "inherit",
+    env
+  });
+  if (result.error) {
+    process.stderr.write(`error: could not run tile-push (${result.error.message})
+`);
+    process.exit(6);
+  }
+  process.exit(result.status ?? 0);
+}
+function registerOtaCommands(program2) {
+  const ota = program2.command("ota").description("Over-the-air (code-push) updates via tile-push \u2014 same appId as the rest of Tile.").addHelpText(
+    "after",
+    [
+      "",
+      "Identity: OTA targets the currently-selected Tile app (`tile use <appId>`),",
+      "authenticated with your `tile login` session. The tenant is auto-provisioned",
+      "on first deploy \u2014 no separate token or `tile-push init` step.",
+      "",
+      "Common flows:",
+      "  tile ota deploy --platform android --rollout 10   ship to 10% of devices",
+      "  tile ota deploy --platform android                ship to everyone (100%)",
+      "  tile ota bundle list                              see what is live",
+      "  tile ota rollback production                      pull the latest bundle",
+      "  tile ota enable <bundle-id> / disable <bundle-id> flip a bundle on/off"
+    ].join("\n")
+  );
+  ota.command("deploy").description("Build and ship a new JS bundle (supports staged --rollout).").option("-p, --platform <platform>", "ios | android").option("-t, --target-app-version <semver>", "target native app version (e.g. 1.0.0, 1.x.x)").option("-c, --channel <channel>", "release channel", "production").option("-r, --rollout <percentage>", "rollout percentage 0-100 (default 100)").option("-d, --disabled", "ship the bundle disabled").option("-f, --force-update", "require an immediate update on next launch").option("-m, --message <message>", "release notes (defaults to latest git commit)").action(() => {
+  });
+  ota.command("rollback").description("Disable the most recent enabled bundle on a channel (devices roll back).").argument("<channel>", "channel to roll back (e.g. production)").option("--platform <platform>", "ios | android").option("--target <bundle-id>", "scope to exactly this bundle id").option("-y, --yes", "skip confirmation").action(() => {
+  });
+  ota.command("enable").description("Re-enable a bundle by id (alias for `ota bundle enable`).").argument("<bundle-id>", "bundle id").option("-y, --yes", "skip confirmation").action(() => {
+  });
+  ota.command("disable").description("Disable a bundle by id (alias for `ota bundle disable`).").argument("<bundle-id>", "bundle id").option("-y, --yes", "skip confirmation").action(() => {
+  });
+  const bundle = ota.command("bundle").description("Inspect and manage individual bundles (list/show/enable/disable/update/promote/delete).");
+  bundle.command("list").description("List bundles, most recent first.").option("-c, --channel <channel>", "filter by channel").option("--platform <platform>", "ios | android").option("--limit <n>", "max results (default 20)").option("--json", "raw JSON output").action(() => {
+  });
+  bundle.command("show").description("Show one bundle by id.").argument("<bundle-id>", "bundle id").option("--json", "raw JSON output").action(() => {
+  });
+  bundle.command("enable").description("Re-enable a bundle by id.").argument("<bundle-id>", "bundle id").option("-y, --yes", "skip confirmation").action(() => {
+  });
+  bundle.command("disable").description("Disable a bundle by id.").argument("<bundle-id>", "bundle id").option("-y, --yes", "skip confirmation").action(() => {
+  });
+  bundle.command("update").description("Adjust a live bundle: rollout cohorts, force-update, targeting.").argument("<bundle-id>", "bundle id").option("--rollout-cohort-count <count>", "rollout cohort count 0-1000 (staged rollout)").option("--force-update <true|false>", "toggle force-update").option("--target-cohorts <cohorts>", "comma-separated target cohorts").option("--clear-target-cohorts", "clear target cohorts").option("-y, --yes", "skip confirmation").option("--json", "raw JSON output").action(() => {
+  });
+  bundle.command("promote").description("Copy or move a bundle to another channel.").argument("<bundle-id>", "bundle id").requiredOption("-t, --target <channel>", "target channel").option("-a, --action <copy|move>", "copy (new id) or move (keep id)", "copy").option("-y, --yes", "skip confirmation").action(() => {
+  });
+  bundle.command("delete").description("Delete a bundle record by id.").argument("<bundle-id>", "bundle id").option("-y, --yes", "skip confirmation").action(() => {
+  });
+  const channel = ota.command("channel").description("Read/set the channel baked into the native app.");
+  channel.command("set").description("Set the channel for Android (BuildConfig) and iOS (Info.plist).").argument("<channel>", "channel to set").action(() => {
+  });
+  const fingerprint = ota.command("fingerprint").description("Native fingerprint (update-eligibility) tooling.");
+  fingerprint.command("create").description("Generate the native fingerprint for this project.").action(() => {
+  });
+  ota.command("whoami").description("Show the active OTA tenant + token (also provisions the tenant on first run).").action(() => {
+  });
+  ota.command("provision").description("Create the OTA tenant for the selected app now (runs whoami; idempotent).").action(() => {
+  });
+  ota.command("doctor").description("Diagnose OTA setup (config, credentials, bundler).").action(() => {
+  });
+  ota.command("info").description("Print resolved OTA settings and where each value came from.").action(() => {
+  });
+  ota.command("console").description("Open the OTA web console for the current tenant.").action(() => {
+  });
+}
+var PROVISION_REWRITE = {
+  provision: ["whoami"]
+};
+function runOtaIntercept(args) {
+  const [first, ...rest] = args;
+  const rewritten = first && PROVISION_REWRITE[first] ? [...PROVISION_REWRITE[first], ...rest] : args;
+  if (first === "provision") {
+    (0, import_core7.hint)("Provisioning the OTA tenant for the selected app (idempotent)\u2026");
+  }
+  runOta(rewritten);
+}
+
+// src/commands/github.ts
+var import_child_process4 = require("child_process");
+var path8 = __toESM(require("path"));
+var import_core8 = __toESM(require_dist());
+var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+function openBrowser(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  try {
+    (0, import_child_process4.spawn)(cmd, [url], { stdio: "ignore", detached: true }).unref();
+  } catch {
+  }
+}
+function registerGithubCommands(program2) {
+  const gh = program2.command("github").alias("gh").description("Connect a Tile app to a GitHub repo (mirror saves).");
+  gh.command("status").description("Show the GitHub connection status for the app.").option("--app <appId>", "app id (or selected app)").action(async (opts) => {
+    const appId = (0, import_core8.resolveApp)(opts);
+    const s = await (0, import_core8.getGithubStatus)(appId);
+    if ((0, import_core8.isJsonMode)()) {
+      (0, import_core8.out)(s);
+      return;
+    }
+    if (!s.connected) {
+      (0, import_core8.info)("GitHub: not connected.");
+      (0, import_core8.hint)("Next: `tile github connect` to authorize.");
+      return;
+    }
+    (0, import_core8.info)(`GitHub: connected${s.githubLogin ? ` as ${s.githubLogin}` : ""}.`);
+    (0, import_core8.info)(`  repo:   ${s.repo || "(none \u2014 run `tile github use <owner/repo>`)"}`);
+    (0, import_core8.info)(`  branch: ${s.defaultBranch}`);
+    (0, import_core8.hint)(s.repo ? "Next: `tile github push` to mirror the latest save." : "Next: `tile github repos` then `tile github use <owner/repo>`.");
+  });
+  gh.command("connect").description("Authorize GitHub via the browser, then wait until connected.").option("--app <appId>", "app id (or selected app)").option("--no-open", "don't auto-open the browser; just print the URL").option("--timeout <seconds>", "how long to wait for authorization", "180").action(async (opts) => {
+    const appId = (0, import_core8.resolveApp)(opts);
+    const existing = await (0, import_core8.getGithubStatus)(appId);
+    if (existing.connected) {
+      (0, import_core8.info)(`Already connected${existing.githubLogin ? ` as ${existing.githubLogin}` : ""}.`);
+      (0, import_core8.hint)("Run `tile github disconnect` first if you want to reconnect.");
+      return;
+    }
+    const url = await (0, import_core8.getInstallUrl)(appId);
+    (0, import_core8.info)("Authorize Tile on GitHub (you must be logged into the Tile web dashboard in this browser):");
+    (0, import_core8.info)(`  ${url}`);
+    if (opts.open !== false) openBrowser(url);
+    const timeoutMs = (parseInt(opts.timeout, 10) || 180) * 1e3;
+    const start = Date.now();
+    (0, import_core8.info)("Waiting for authorization\u2026");
+    while (Date.now() - start < timeoutMs) {
+      await sleep2(3e3);
+      let s;
+      try {
+        s = await (0, import_core8.getGithubStatus)(appId);
+      } catch {
+        continue;
+      }
+      if (s.connected) {
+        if ((0, import_core8.isJsonMode)()) (0, import_core8.out)(s);
+        else (0, import_core8.info)(`\u2713 Connected${s.githubLogin ? ` as ${s.githubLogin}` : ""}.`);
+        (0, import_core8.hint)("Next: `tile github repos` then `tile github use <owner/repo>`.");
+        return;
+      }
+    }
+    throw new import_core8.TileError(
+      "Timed out waiting for GitHub authorization.",
+      import_core8.ExitCode.ERROR,
+      "Re-run `tile github connect`; ensure you completed the browser flow while logged into the Tile web dashboard."
+    );
+  });
+  gh.command("disconnect").description("Remove the GitHub connection for the app.").option("--app <appId>", "app id (or selected app)").option("-y, --yes", "skip the confirmation prompt").action(async (opts) => {
+    const appId = (0, import_core8.resolveApp)(opts);
+    if (!opts.yes) {
+      throw new import_core8.TileError(
+        `Refusing to disconnect GitHub for ${appId} without confirmation.`,
+        import_core8.ExitCode.USAGE,
+        "Re-run with --yes to confirm."
+      );
+    }
+    await (0, import_core8.disconnectGithub)(appId);
+    if ((0, import_core8.isJsonMode)()) (0, import_core8.out)({ ok: true, appId });
+    else (0, import_core8.info)(`\u2713 Disconnected GitHub for ${appId}.`);
+  });
+  gh.command("repos").description("List repos the connected GitHub account can access.").option("--app <appId>", "app id (or selected app)").option("--page <n>", "page number", "1").action(async (opts) => {
+    const appId = (0, import_core8.resolveApp)(opts);
+    const { repos, hasMore } = await (0, import_core8.listUserRepos)(appId, parseInt(opts.page, 10) || 1);
+    if ((0, import_core8.isJsonMode)()) {
+      (0, import_core8.out)(repos);
+      return;
+    }
+    if (!repos.length) (0, import_core8.info)("No repos visible to the connected token.");
+    else for (const r of repos) (0, import_core8.info)(`${r.fullName}${r.private ? "  (private)" : ""}`);
+    (0, import_core8.hint)(`${hasMore ? "(more \u2014 use --page) " : ""}Next: \`tile github use <owner/repo>\`.`);
+  });
+  gh.command("use <ownerRepo>").description("Select the repo to sync with (owner/repo).").option("--app <appId>", "app id (or selected app)").action(async (ownerRepo, opts) => {
+    const appId = (0, import_core8.resolveApp)(opts);
+    const slash = ownerRepo.indexOf("/");
+    if (slash < 0) throw new import_core8.TileError("Expected <owner/repo>.", import_core8.ExitCode.USAGE);
+    const owner = ownerRepo.slice(0, slash);
+    const repo = ownerRepo.slice(slash + 1);
+    const res = await (0, import_core8.connectRepo)(appId, owner, repo);
+    if ((0, import_core8.isJsonMode)()) (0, import_core8.out)(res);
+    else (0, import_core8.info)(`\u2713 Connected ${res.repo} (default branch ${res.defaultBranch}).`);
+    (0, import_core8.hint)("Next: `tile github push` to mirror the latest save to the repo.");
+  });
+  gh.command("push").description("Push the latest save to the connected GitHub repo.").option("--app <appId>", "app id (or selected app)").option("-b, --branch <branch>", "target branch (default: the repo default)").option("-m, --message <message>", "commit message").action(async (opts) => {
+    const appId = (0, import_core8.resolveApp)(opts);
+    const res = await (0, import_core8.githubPush)(appId, { branch: opts.branch, message: opts.message });
+    if ((0, import_core8.isJsonMode)()) (0, import_core8.out)(res);
+    else (0, import_core8.info)(`\u2713 Pushed${res.branch ? ` to ${res.branch}` : ""}${res.saveId ? ` (save ${res.saveId})` : ""}.`);
+  });
+  gh.command("pull").description("Resync from GitHub: materialize the branch HEAD into a new save and write it locally (GitHub \u2192 Tile).").option("--app <appId>", "app id (or selected app)").option("-b, --branch <branch>", "branch to pull (default: the repo default)").option("--out <dir>", "output directory", ".").option("-f, --force", "proceed even if the cloud has diverged from git (last-writer-wins)").action(async (opts) => {
+    const appId = (0, import_core8.resolveApp)(opts);
+    const status = await (0, import_core8.getGithubStatus)(appId);
+    if (!status.connected || !status.repo) {
+      throw new import_core8.TileError(
+        `App ${appId} is not connected to a GitHub repo.`,
+        import_core8.ExitCode.USAGE,
+        "Run `tile github connect` then `tile github use <owner/repo>`."
+      );
+    }
+    const branch = opts.branch || status.defaultBranch;
+    const drift = await (0, import_core8.getBranchDrift)(appId, branch);
+    if (drift.reason === "git_branch_gone") {
+      throw new import_core8.TileError(
+        `Branch ${branch} no longer exists on GitHub.`,
+        import_core8.ExitCode.NOT_FOUND,
+        "Pick another branch with --branch, or recreate it on GitHub."
+      );
+    }
+    if (drift.hasDrift && drift.unpushedSaveCount > 0 && !opts.force) {
+      throw new import_core8.TileError(
+        `Cloud has diverged from git on ${branch}: ${drift.unpushedSaveCount} cloud save(s) are not reflected in git. Pulling makes git's state current; those saves stay in history (revertable via \`tile saves\`/\`tile revert\`).`,
+        import_core8.ExitCode.CONFLICT,
+        "Re-run with --force to proceed (last-writer-wins)."
+      );
+    }
+    const mat = await (0, import_core8.materializeBranch)(appId, branch);
+    const dir = path8.resolve(process.cwd(), opts.out);
+    const n = await writeSaveToDir(appId, mat.saveId, dir);
+    if ((0, import_core8.isJsonMode)()) {
+      (0, import_core8.out)({ appId, branch, saveId: mat.saveId, baseGitSha: mat.baseGitSha, cached: mat.cached, files: n, dir });
+      return;
+    }
+    (0, import_core8.info)(
+      `\u2713 Resynced ${branch}@${mat.baseGitSha.slice(0, 7)} \u2192 save ${mat.saveId} (${n} files${mat.cached ? ", cached" : ""}) \u2192 ${opts.out}`
+    );
+    (0, import_core8.hint)("Next: edit, then `tile save`. Or `tile build create --platform android`.");
+  });
+  gh.command("drift").description("Check whether the GitHub branch has advanced past the latest cloud save (verify).").option("--app <appId>", "app id (or selected app)").option("-b, --branch <branch>", "branch to check (default: the repo default)").action(async (opts) => {
+    const appId = (0, import_core8.resolveApp)(opts);
+    const status = await (0, import_core8.getGithubStatus)(appId);
+    if (!status.connected || !status.repo) {
+      throw new import_core8.TileError(
+        `App ${appId} is not connected to a GitHub repo.`,
+        import_core8.ExitCode.USAGE,
+        "Run `tile github connect` then `tile github use <owner/repo>`."
+      );
+    }
+    const branch = opts.branch || status.defaultBranch;
+    const d = await (0, import_core8.getBranchDrift)(appId, branch);
+    if ((0, import_core8.isJsonMode)()) {
+      (0, import_core8.out)({ appId, branch, ...d });
+      return;
+    }
+    if (!d.hasDrift) {
+      (0, import_core8.info)(`\u2713 In sync on ${branch}${d.reason === "no_cloud_saves" ? " (no cloud saves yet)" : ""}.`);
+    } else if (d.reason === "git_branch_gone") {
+      (0, import_core8.info)(`\u26A0 Branch ${branch} was deleted on GitHub.`);
+    } else {
+      (0, import_core8.info)(
+        `\u26A0 Drift on ${branch}: git advanced to ${d.currentGitSha?.slice(0, 7)}; ${d.unpushedSaveCount} cloud save(s) on old base ${d.cloudBaseSha?.slice(0, 7)}.`
+      );
+      (0, import_core8.hint)("Next: `tile github pull` to resync (last-writer-wins).");
+    }
+  });
+}
+
+// src/commands/integrations.ts
+var readline2 = __toESM(require("readline"));
+var import_stream2 = require("stream");
+var import_core9 = __toESM(require_dist());
+function prompt2(question, mask = false) {
+  if (!process.stdin.isTTY) {
+    throw new import_core9.TileError(
+      "Cannot prompt for input: this is not an interactive terminal.",
+      import_core9.ExitCode.USAGE,
+      "Pass the values non-interactively with repeated --field key=value flags."
+    );
+  }
+  return new Promise((resolve7) => {
+    let muted = false;
+    const mutableOut = new import_stream2.Writable({
+      write(chunk, _enc, cb) {
+        if (!muted) process.stderr.write(chunk);
+        cb();
+      }
+    });
+    const rl = readline2.createInterface({ input: process.stdin, output: mutableOut, terminal: true });
+    process.stderr.write(question);
+    if (mask) muted = true;
+    rl.question("", (answer) => {
+      if (mask) process.stderr.write("\n");
+      rl.close();
+      resolve7(answer.trim());
+    });
+  });
+}
+function parseFieldFlags(raw) {
+  const out12 = {};
+  for (const kv of raw || []) {
+    const i = kv.indexOf("=");
+    if (i <= 0) throw new import_core9.TileError(`Bad --field "${kv}" (expected key=value).`, import_core9.ExitCode.USAGE);
+    out12[kv.slice(0, i)] = kv.slice(i + 1);
+  }
+  return out12;
+}
+var collectField = (val, prev) => [...prev, val];
+function registerIntegrationsCommands(program2) {
+  const integ = program2.command("integrations").alias("int").description("Connect third-party integrations (Supabase, Shopify, custom) for an app.");
+  integ.command("list").description("Show connected integrations and what is available.").option("--app <appId>", "app id (or selected app)").action(async (opts) => {
+    const appId = (0, import_core9.resolveApp)(opts);
+    const data = await (0, import_core9.listIntegrations)(appId);
+    if ((0, import_core9.isJsonMode)()) {
+      (0, import_core9.out)(data);
+      return;
+    }
+    (0, import_core9.info)(`Secret store: ${data.secretStore}`);
+    (0, import_core9.info)("");
+    (0, import_core9.info)("Connected:");
+    if (!data.connected.length) (0, import_core9.info)("  (none)");
+    for (const c of data.connected) {
+      const pub = Object.entries(c.publicConfig).map(([k, v]) => `${k}=${v}`).join(", ");
+      (0, import_core9.info)(`  ${c.provider}${c.category ? `/${c.category}` : ""}  [${c.status}]  ${pub}`);
+      if (c.secretKeys.length) (0, import_core9.info)(`    secrets: ${c.secretKeys.join(", ")} (stored)`);
+    }
+    (0, import_core9.info)("");
+    (0, import_core9.info)("Available providers:");
+    for (const s of data.available) (0, import_core9.info)(`  ${s.provider}  (${s.category})  \u2014 fields: ${s.fields.map((f) => f.key + (f.secret ? "*" : "")).join(", ")}`);
+    (0, import_core9.info)("  custom  \u2014 any category, give --field key=value (prefix public: for non-secret)");
+    (0, import_core9.hint)("Connect: `tile integrations connect <provider> --app <id>` (you'll be prompted for keys).");
+  });
+  integ.command("connect <provider>").description("Connect a provider (supabase | shopify | custom). Prompts for credentials.").option("--app <appId>", "app id (or selected app)").option("--category <category>", "category (required for custom)").option("--field <key=value>", "set a field non-interactively (repeatable)", collectField, []).action(async (provider, opts) => {
+    const appId = (0, import_core9.resolveApp)(opts);
+    const fields = parseFieldFlags(opts.field);
+    let category = opts.category;
+    if (provider === "custom") {
+      if (!category) category = await prompt2("Category (e.g. payments, analytics): ");
+      if (!category) throw new import_core9.TileError("Custom integration requires a category.", import_core9.ExitCode.USAGE);
+      if (!Object.keys(fields).length) {
+        (0, import_core9.info)('Enter credential fields. Blank key to finish. Prefix a key with "public:" if it is NOT secret.');
+        while (true) {
+          const key = await prompt2("  field key (blank to finish): ");
+          if (!key) break;
+          const secret = !key.startsWith("public:");
+          const value = await prompt2(`  value for ${key}${secret ? " (hidden)" : ""}: `, secret);
+          if (value) fields[key] = value;
+        }
+      }
+    } else {
+      const { available } = await (0, import_core9.listIntegrations)(appId);
+      const spec = available.find((s) => s.provider === provider);
+      if (!spec) {
+        throw new import_core9.TileError(
+          `Unknown provider "${provider}". Known: ${available.map((s) => s.provider).join(", ")}, or "custom".`,
+          import_core9.ExitCode.USAGE
+        );
+      }
+      for (const f of spec.fields) {
+        if (fields[f.key] !== void 0) continue;
+        if (!process.stdin.isTTY) continue;
+        const meta = [f.optional ? "optional" : null, f.example ? `e.g. ${f.example}` : null].filter(Boolean).join(", ");
+        if (f.help) (0, import_core9.info)(`  ${f.label}: ${f.help}`);
+        const v = await prompt2(`${f.label}${meta ? ` (${meta})` : ""}${f.secret ? " (hidden)" : ""}: `, f.secret);
+        if (v) fields[f.key] = v;
+      }
+    }
+    const res = await (0, import_core9.connectIntegration)(appId, provider, { category, fields });
+    if ((0, import_core9.isJsonMode)()) {
+      (0, import_core9.out)(res);
+      return;
+    }
+    (0, import_core9.info)(`\u2713 ${res.updated ? "Updated" : "Connected"} ${provider}${res.category ? `/${res.category}` : ""}.`);
+    const stored = res.secretKeys?.length ? ` Secrets stored: ${res.secretKeys.join(", ")}.` : "";
+    (0, import_core9.info)(`  Public config: ${Object.entries(res.publicConfig || {}).map(([k, v]) => `${k}=${v}`).join(", ") || "(none)"}.${stored}`);
+    (0, import_core9.hint)("The AI agent will now use this connection automatically when relevant.");
+  });
+  integ.command("resolve <provider>").description("Fetch a connection's config + secrets (for the AI agent / scripts). Prints secrets \u2014 use with care.").option("--app <appId>", "app id (or selected app)").option("--category <category>", "category (for custom providers)").action(async (provider, opts) => {
+    const appId = (0, import_core9.resolveApp)(opts);
+    const r = await (0, import_core9.resolveIntegration)(appId, provider, opts.category);
+    if ((0, import_core9.isJsonMode)()) {
+      (0, import_core9.out)(r);
+      return;
+    }
+    (0, import_core9.info)(`${r.provider}${r.category ? `/${r.category}` : ""}${r.capability ? `  (capability: ${r.capability})` : ""}`);
+    for (const [k, v] of Object.entries(r.publicConfig || {})) (0, import_core9.info)(`  ${k} = ${v}`);
+    for (const [k, v] of Object.entries(r.secrets || {})) (0, import_core9.info)(`  ${k} = ${v}  (secret)`);
+    (0, import_core9.hint)("Tip: add --json for machine-readable output.");
+  });
+  integ.command("disconnect <provider>").description("Remove a connection.").option("--app <appId>", "app id (or selected app)").option("--category <category>", "category (for custom providers)").action(async (provider, opts) => {
+    const appId = (0, import_core9.resolveApp)(opts);
+    const res = await (0, import_core9.disconnectIntegration)(appId, provider, opts.category);
+    if ((0, import_core9.isJsonMode)()) {
+      (0, import_core9.out)(res);
+      return;
+    }
+    (0, import_core9.info)(res.removed ? `\u2713 Disconnected ${provider}.` : `Nothing to disconnect for ${provider}.`);
+  });
+}
+
+// src/commands/assets.ts
+var path9 = __toESM(require("path"));
+var import_core10 = __toESM(require_dist());
+function registerAssetCommands(program2) {
+  const assets = program2.command("assets").description("Manage an app's asset library (shared with the dashboard image picker).");
+  assets.command("upload <file>").description("Upload a local file to the app asset library; returns the URL to embed.").option("--app <appId>", "app id (or selected app)").action(async (file, opts) => {
+    const appId = (0, import_core10.resolveApp)(opts);
+    const asset = await (0, import_core10.uploadAsset)(appId, file);
+    if ((0, import_core10.isJsonMode)()) {
+      (0, import_core10.out)(asset);
+      return;
+    }
+    (0, import_core10.info)(`\u2713 Uploaded ${path9.basename(file)} (${asset.sizeBytes} bytes, ${asset.mimeType})`);
+    (0, import_core10.out)(asset.url);
+    (0, import_core10.hint)(
+      `Embed in app code as:  source={{ uri: '${asset.url}' }}`,
+      "It now also appears in the dashboard Library tab."
+    );
+  });
+  assets.command("list").alias("ls").description("List the app asset library.").option("--app <appId>", "app id (or selected app)").action(async (opts) => {
+    const appId = (0, import_core10.resolveApp)(opts);
+    const items = await (0, import_core10.listAssets)(appId);
+    if ((0, import_core10.isJsonMode)()) {
+      (0, import_core10.out)({ assets: items });
+      return;
+    }
+    if (!items.length) {
+      (0, import_core10.info)("(no assets)");
+      (0, import_core10.hint)("Upload one: `tile assets upload <file> --app " + appId + "`");
+      return;
+    }
+    for (const a of items) (0, import_core10.info)(`  ${a.id}  ${a.mimeType}  ${a.sizeBytes}B  ${a.url}`);
+  });
+  assets.command("delete <assetId>").alias("rm").description("Delete an asset by id.").option("--app <appId>", "app id (or selected app)").action(async (assetId, opts) => {
+    const appId = (0, import_core10.resolveApp)(opts);
+    await (0, import_core10.deleteAsset)(appId, assetId);
+    if ((0, import_core10.isJsonMode)()) {
+      (0, import_core10.out)({ deleted: true, id: assetId });
+      return;
+    }
+    (0, import_core10.info)(`\u2713 Deleted ${assetId}`);
+  });
+}
+
+// src/commands/test.ts
+var fs7 = __toESM(require("fs"));
+var path10 = __toESM(require("path"));
+var import_child_process5 = require("child_process");
+var import_core11 = __toESM(require_dist());
+var YAML_RE = /\.ya?ml$/i;
+function probe(cmd, args) {
+  const r = (0, import_child_process5.spawnSync)(cmd, args, { encoding: "utf8" });
+  return { found: !r.error, status: r.status, out: `${r.stdout || ""}${r.stderr || ""}` };
+}
+function hasFlow(dir, depth = 2) {
+  let entries;
+  try {
+    entries = fs7.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return false;
+  }
+  for (const e of entries) {
+    if (e.isFile() && YAML_RE.test(e.name)) return true;
+    if (e.isDirectory() && depth > 0 && hasFlow(path10.join(dir, e.name), depth - 1)) return true;
+  }
+  return false;
+}
+function findFlows(root, override) {
+  const candidates = override ? [override] : ["maestro", ".maestro"];
+  for (const c of candidates) {
+    const dir = path10.resolve(root, c);
+    if (fs7.existsSync(dir) && fs7.statSync(dir).isDirectory() && hasFlow(dir)) return dir;
+  }
+  return null;
+}
+var SRC_EXTS = /* @__PURE__ */ new Set([".js", ".jsx", ".ts", ".tsx"]);
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", "android", "ios", ".git", ".expo", "build", "dist", ".next"]);
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function collectSource(root) {
+  const files = [];
+  const walk2 = (dir, depth) => {
+    if (depth < 0) return;
+    let entries;
+    try {
+      entries = fs7.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (e.isDirectory()) {
+        if (!SKIP_DIRS.has(e.name) && !e.name.startsWith(".")) walk2(path10.join(dir, e.name), depth - 1);
+      } else if (SRC_EXTS.has(path10.extname(e.name))) {
+        files.push(path10.join(dir, e.name));
+      }
+    }
+  };
+  walk2(root, 6);
+  let corpus = "";
+  const testIds = /* @__PURE__ */ new Set();
+  const labelPatterns = [];
+  const addLiteral = (s) => labelPatterns.push({ raw: s, re: new RegExp(`^${escapeRe(s)}$`) });
+  const addTemplate = (tpl) => {
+    const pat = tpl.replace(/\$\{[^}]*\}/g, "\0").split("\0").map(escapeRe).join(".*");
+    labelPatterns.push({ raw: tpl, re: new RegExp(`^${pat}$`) });
+  };
+  for (const f of files) {
+    let txt;
+    try {
+      txt = fs7.readFileSync(f, "utf8");
+    } catch {
+      continue;
+    }
+    corpus += `
+${txt}`;
+    for (const m of txt.matchAll(
+      /testID\s*=\s*(?:"([^"]+)"|'([^']+)'|\{\s*(?:"([^"]+)"|'([^']+)'|`([^`]+)`)\s*\})/g
+    )) {
+      const v = m[1] ?? m[2] ?? m[3] ?? m[4] ?? m[5];
+      if (v) testIds.add(v);
+    }
+    for (const m of txt.matchAll(/accessibilityLabel\s*=\s*(?:"([^"]+)"|'([^']+)')/g)) {
+      const v = m[1] ?? m[2];
+      if (v) addLiteral(v);
+    }
+    for (const m of txt.matchAll(/accessibilityLabel\s*=\s*\{\s*`([^`]+)`\s*\}/g)) addTemplate(m[1]);
+    for (const m of txt.matchAll(/\bname\s*=\s*(?:"([^"]+)"|'([^']+)')/g)) {
+      const v = m[1] ?? m[2];
+      if (v) addLiteral(v);
+    }
+  }
+  return { corpus, testIds, labelPatterns };
+}
+function unquote(s) {
+  const t = s.trim();
+  if (t.startsWith('"') && t.endsWith('"') || t.startsWith("'") && t.endsWith("'")) return t.slice(1, -1);
+  return t;
+}
+function parseFlow(text) {
+  const lines = text.split("\n");
+  const selectors = [];
+  let commandCount = 0;
+  const appId = text.match(/^appId:\s*(.+)$/m)?.[1] ? unquote(text.match(/^appId:\s*(.+)$/m)[1]) : null;
+  const SELECTOR_CMDS = /^\s*-?\s*(tapOn|assertVisible|assertNotVisible|longPressOn|doubleTapOn):\s*(.*)$/;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (/^\s*-\s+\S/.test(line)) commandCount++;
+    const m = line.match(SELECTOR_CMDS);
+    if (!m) continue;
+    const cmd = m[1];
+    const inline = m[2].trim();
+    if (inline && !inline.startsWith("#")) {
+      if (inline.startsWith("{")) {
+        const idIn = inline.match(/id:\s*("[^"]+"|'[^']+'|[^,}\s]+)/);
+        const txIn = inline.match(/text:\s*("[^"]+"|'[^']+'|[^,}]+)/);
+        if (idIn) selectors.push({ kind: "id", value: unquote(idIn[1]), cmd, line: i + 1 });
+        else if (txIn) selectors.push({ kind: "text", value: unquote(txIn[1]), cmd, line: i + 1 });
+      } else {
+        selectors.push({ kind: "text", value: unquote(inline), cmd, line: i + 1 });
+      }
+      continue;
+    }
+    const baseIndent = line.search(/\S/);
+    for (let j = i + 1; j < lines.length; j++) {
+      if (!lines[j].trim()) continue;
+      if (lines[j].search(/\S/) <= baseIndent) break;
+      const idM = lines[j].match(/^\s*id:\s*(.+)$/);
+      const txM = lines[j].match(/^\s*text:\s*(.+)$/);
+      if (idM) selectors.push({ kind: "id", value: unquote(idM[1]), cmd, line: j + 1 });
+      else if (txM) selectors.push({ kind: "text", value: unquote(txM[1]), cmd, line: j + 1 });
+    }
+  }
+  return { appId, commandCount, selectors };
+}
+function resolveText(value, src) {
+  const core = value.replace(/^\^/, "").replace(/\$$/, "").replace(/^\.\*/, "").replace(/\.\*$/, "").trim();
+  if (!core) return true;
+  if (src.corpus.includes(core)) return true;
+  for (const p of src.labelPatterns) if (p.re.test(core) || p.re.test(value)) return true;
+  const words = core.split(/\s+/).filter((w) => w.replace(/[^A-Za-z0-9]/g, "").length > 2);
+  return words.length > 0 && words.every((w) => src.corpus.includes(w));
+}
+function lintFlows(root, flowsDir) {
+  const issues = [];
+  const src = collectSource(root);
+  const pkg = appPackage(root);
+  const flowFiles = [];
+  const gather = (dir) => {
+    for (const e of fs7.readdirSync(dir, { withFileTypes: true })) {
+      if (e.isFile() && YAML_RE.test(e.name)) flowFiles.push(path10.join(dir, e.name));
+      else if (e.isDirectory()) gather(path10.join(dir, e.name));
+    }
+  };
+  gather(flowsDir);
+  for (const f of flowFiles.sort()) {
+    const rel = path10.relative(root, f) || path10.basename(f);
+    let text;
+    try {
+      text = fs7.readFileSync(f, "utf8");
+    } catch {
+      continue;
+    }
+    const { appId, commandCount, selectors } = parseFlow(text);
+    if (!appId) {
+      issues.push({ level: "error", flow: rel, line: 1, msg: "no `appId:` \u2014 Maestro needs it to launch the app." });
+    } else if (pkg && appId !== pkg) {
+      issues.push({
+        level: "error",
+        flow: rel,
+        line: 1,
+        msg: `appId "${appId}" \u2260 the app's Android applicationId "${pkg}" \u2014 the flow targets the wrong app.`
+      });
+    }
+    if (commandCount === 0) issues.push({ level: "warn", flow: rel, line: 1, msg: "flow has no commands." });
+    for (const s of selectors) {
+      if (s.kind === "id") {
+        if (!src.testIds.has(s.value)) {
+          const looksLikeLabel = src.labelPatterns.some((p) => p.re.test(s.value));
+          issues.push({
+            level: "error",
+            flow: rel,
+            line: s.line,
+            msg: looksLikeLabel ? `${s.cmd} id: "${s.value}" \u2014 that's an accessibilityLabel, not a testID. \`id:\` matches testID/resource-id only. Use \`${s.cmd}: "${s.value}"\` (text), or add testID="${s.value}" in the code.` : `${s.cmd} id: "${s.value}" \u2014 no testID="${s.value}" in the app source. \`id:\` matches a React Native testID only.`
+          });
+        }
+      } else if (s.cmd === "tapOn" || s.cmd === "longPressOn" || s.cmd === "doubleTapOn") {
+        if (!resolveText(s.value, src)) {
+          issues.push({
+            level: "warn",
+            flow: rel,
+            line: s.line,
+            msg: `${s.cmd}: "${s.value}" \u2014 no matching accessibilityLabel, screen name, or text in the app source. Likely a typo or a guessed selector; tap something you explicitly labeled.`
+          });
+        }
+      }
+    }
+  }
+  return issues;
+}
+function printLint(issues, relFlows) {
+  (0, import_core11.info)(`\u25B8 lint: ${relFlows}`);
+  if (!issues.length) {
+    (0, import_core11.info)("  \u2713 no issues found");
+    return;
+  }
+  for (const i of issues) (0, import_core11.info)(`  ${i.level === "error" ? "\u2717" : "\u26A0"} ${i.flow}:${i.line} \u2014 ${i.msg}`);
+}
+function preflightTools() {
+  const checks = [];
+  const m = probe("maestro", ["-v"]);
+  checks.push({
+    name: "Maestro CLI",
+    ok: m.found,
+    detail: m.found ? m.out.trim().split("\n")[0] || "installed" : "not found on PATH",
+    fix: m.found ? void 0 : 'Install Maestro: curl -Ls "https://get.maestro.mobile.dev" | bash  (then add ~/.maestro/bin to PATH)'
+  });
+  const javaBin = process.env.JAVA_HOME ? path10.join(process.env.JAVA_HOME, "bin", "java") : "java";
+  const j = probe(javaBin, ["-version"]);
+  const major = j.found ? j.out.match(/version "(\d+)/)?.[1] ?? null : null;
+  const jdkOk = major === "17";
+  const src = process.env.JAVA_HOME ? "JAVA_HOME" : "PATH";
+  checks.push({
+    name: "JDK 17",
+    ok: jdkOk,
+    detail: !j.found ? `java not found (${src})` : jdkOk ? `java 17 (${src})` : `java ${major ?? "?"} (${src}; need 17)`,
+    fix: jdkOk ? void 0 : "Use JDK 17: export JAVA_HOME=$(/usr/libexec/java_home -v 17)  (install if missing: brew install --cask temurin@17)"
+  });
+  const adb = probe("adb", ["version"]);
+  checks.push({
+    name: "Android SDK (adb)",
+    ok: adb.found,
+    detail: adb.found ? adb.out.trim().split("\n")[0] || "installed" : "adb not found",
+    fix: adb.found ? void 0 : "Install the Android SDK + platform-tools (Android Studio), set ANDROID_HOME, and put platform-tools on PATH."
+  });
+  return checks;
+}
+function connectedDevices() {
+  return probe("adb", ["devices"]).out.split("\n").slice(1).filter((l) => /\tdevice\s*$/.test(l)).map((l) => l.split("	")[0]);
+}
+function listAvds() {
+  return probe("emulator", ["-list-avds"]).out.trim().split("\n").filter(Boolean);
+}
+function appPackage(root) {
+  try {
+    const gradle = fs7.readFileSync(path10.join(root, "android", "app", "build.gradle"), "utf8");
+    const id = gradle.match(/applicationId\s+['"]([^'"]+)['"]/)?.[1];
+    if (id) return id;
+  } catch {
+  }
+  try {
+    const cfg = JSON.parse(fs7.readFileSync(path10.join(root, "app.json"), "utf8"));
+    return cfg?.expo?.android?.package ?? null;
+  } catch {
+    return null;
+  }
+}
+function isInstalled(pkg) {
+  return probe("adb", ["shell", "pm", "list", "packages", pkg]).out.includes(`package:${pkg}`);
+}
+function installApk(apk, device) {
+  (0, import_core11.info)(`\u25B8 installing ${path10.basename(apk)}\u2026`);
+  const args = device ? ["-s", device, "install", "-r", apk] : ["install", "-r", apk];
+  const inst = (0, import_child_process5.spawnSync)("adb", args, { stdio: "inherit" });
+  if (inst.status !== 0) throw new import_core11.TileError("adb install failed.", import_core11.ExitCode.ERROR);
+}
+function buildAndInstallAndroid(root, device) {
+  const androidDir = path10.join(root, "android");
+  if (!fs7.existsSync(androidDir)) {
+    (0, import_core11.info)("\u25B8 generating native android project (expo prebuild)\u2026");
+    const pb = (0, import_child_process5.spawnSync)("npx", ["expo", "prebuild", "--platform", "android", "--no-install"], {
+      stdio: "inherit",
+      cwd: root
+    });
+    if (pb.status !== 0) throw new import_core11.TileError("expo prebuild failed.", import_core11.ExitCode.ERROR);
+  }
+  (0, import_core11.info)("\u25B8 building release APK (gradle assembleRelease)\u2026");
+  const gradlew = process.platform === "win32" ? "gradlew.bat" : "./gradlew";
+  const g = (0, import_child_process5.spawnSync)(gradlew, [":app:assembleRelease"], { stdio: "inherit", cwd: androidDir });
+  if (g.status !== 0) throw new import_core11.TileError("gradle build failed.", import_core11.ExitCode.ERROR);
+  const apk = path10.join(androidDir, "app/build/outputs/apk/release/app-release.apk");
+  if (!fs7.existsSync(apk)) throw new import_core11.TileError(`release APK not found at ${apk}.`, import_core11.ExitCode.ERROR);
+  installApk(apk, device);
+}
+function emulatorBin() {
+  const home = process.env.ANDROID_HOME || process.env.ANDROID_SDK_ROOT;
+  if (home) {
+    const p = path10.join(home, "emulator", "emulator");
+    if (fs7.existsSync(p)) return p;
+  }
+  return "emulator";
+}
+function waitForBoot(timeoutMs) {
+  (0, import_child_process5.spawnSync)("adb", ["wait-for-device"], { stdio: "ignore" });
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (probe("adb", ["shell", "getprop", "sys.boot_completed"]).out.trim() === "1") return true;
+    (0, import_child_process5.spawnSync)("sleep", ["2"]);
+  }
+  return false;
+}
+function ensureDevice(opts) {
+  if (opts.device || connectedDevices().length) return;
+  const avds = listAvds();
+  if (!avds.length) {
+    throw new import_core11.TileError(
+      "no device connected and no emulator (AVD) found.",
+      import_core11.ExitCode.ERROR,
+      "Connect a device (USB debugging) or create an AVD in Android Studio (needs a system image)."
+    );
+  }
+  if (opts.boot === false) {
+    throw new import_core11.TileError("no device connected (--no-boot set).", import_core11.ExitCode.ERROR, `Start one: emulator -avd ${avds[0]}`);
+  }
+  const avd = opts.avd || avds[0];
+  if (!avds.includes(avd)) {
+    throw new import_core11.TileError(`AVD "${avd}" not found.`, import_core11.ExitCode.ERROR, `Available: ${avds.join(", ")}`);
+  }
+  (0, import_core11.info)(`\u25B8 no device connected \u2014 booting emulator "${avd}" headless\u2026`);
+  (0, import_child_process5.spawn)(
+    emulatorBin(),
+    ["-avd", avd, "-no-window", "-no-boot-anim", "-no-snapshot", "-gpu", "swiftshader_indirect"],
+    { detached: true, stdio: "ignore" }
+  ).unref();
+  if (!waitForBoot(12e4)) {
+    throw new import_core11.TileError(
+      "emulator did not finish booting in time.",
+      import_core11.ExitCode.ERROR,
+      "Boot it manually (emulator -avd <name>) and re-run."
+    );
+  }
+  (0, import_core11.info)("  \u2713 emulator ready");
+}
+function registerTestCommands(program2) {
+  const test = program2.command("test").description(
+    "Run this project's Maestro e2e flows (L3). Local-first; the same flows run on the farm via --remote."
+  ).option("--local", "run in this environment (default)", true).option("--remote", "run on the Tile farm (provisions a pinned machine, runs `tile test --local` there)").option("--device <id>", "target device/emulator (adb id); default: first connected device").option("--avd <name>", "AVD to auto-boot when no device is connected (default: first available)").option("--no-boot", "do not auto-boot an emulator; fail if no device is connected").option("--apk <path>", "install + test this pre-built APK instead of building (the pipeline path \u2014 tests exactly what ships)").option("--build", "force a rebuild + install (otherwise auto-builds only when the app is not installed)").option("--platform <p>", "android (ios later)", "android").option("--flows <dir>", "flow directory (default: maestro/ then .maestro/)").option("--lint", "static-check the flows against the app source (no device/build), then exit").option("--skip-lint", "skip the automatic static pre-lint before building").action(
+    async (opts) => {
+      if (opts.remote) {
+        throw new import_core11.TileError(
+          "tile test --remote is not implemented yet (roadmap \xA73 phase 4).",
+          import_core11.ExitCode.UNSUPPORTED,
+          "For now run `tile test --local` (the same script the farm will call)."
+        );
+      }
+      if (opts.platform !== "android") {
+        throw new import_core11.TileError(
+          `platform "${opts.platform}" is not supported yet \u2014 Android-first.`,
+          import_core11.ExitCode.UNSUPPORTED,
+          "iOS testing lands later on the Tart mac substrate (roadmap \xA73)."
+        );
+      }
+      const root = process.cwd();
+      const flowsDir = findFlows(root, opts.flows);
+      if (!flowsDir) {
+        throw new import_core11.TileError(
+          "testing not configured for this project \u2014 no Maestro flows found (looked for maestro/ then .maestro/).",
+          import_core11.ExitCode.UNSUPPORTED,
+          "Add maestro/<flow>.yaml, or scaffold from the `base` blueprint (it ships flows + a CLAUDE.md test rule)."
+        );
+      }
+      const relFlows = path10.relative(root, flowsDir) || flowsDir;
+      if (opts.lint) {
+        const issues = lintFlows(root, flowsDir);
+        const errors = issues.filter((i) => i.level === "error");
+        if ((0, import_core11.isJsonMode)()) (0, import_core11.out)({ ok: errors.length === 0, stage: "lint", flows: relFlows, issues });
+        else {
+          printLint(issues, relFlows);
+          if (issues.length)
+            (0, import_core11.hint)("", `${errors.length} error(s), ${issues.length - errors.length} warning(s).`);
+        }
+        if (errors.length) throw new import_core11.TileError(`lint failed: ${errors.length} error(s).`, import_core11.ExitCode.ERROR);
+        return;
+      }
+      if (!opts.skipLint) {
+        const issues = lintFlows(root, flowsDir);
+        const errors = issues.filter((i) => i.level === "error");
+        if (errors.length) {
+          if ((0, import_core11.isJsonMode)()) (0, import_core11.out)({ ok: false, stage: "lint", flows: relFlows, issues });
+          else {
+            printLint(issues, relFlows);
+            (0, import_core11.hint)("", "Fix the flow errors above and re-run, or pass --skip-lint to bypass.");
+          }
+          throw new import_core11.TileError(`lint failed: ${errors.length} error(s).`, import_core11.ExitCode.ERROR);
+        }
+        if (!(0, import_core11.isJsonMode)() && issues.length) printLint(issues, relFlows);
+      }
+      const checks = preflightTools();
+      const failed = checks.filter((c) => !c.ok);
+      if ((0, import_core11.isJsonMode)()) {
+        if (failed.length) {
+          (0, import_core11.out)({ ok: false, stage: "preflight", flows: relFlows, checks });
+          throw new import_core11.TileError("preflight failed", import_core11.ExitCode.ERROR);
+        }
+      } else {
+        (0, import_core11.info)(`\u25B8 flows: ${relFlows}`);
+        for (const c of checks) (0, import_core11.info)(`  ${c.ok ? "\u2713" : "\u2717"} ${c.name}: ${c.detail}`);
+      }
+      if (failed.length) {
+        (0, import_core11.hint)("", "Environment not ready. Fix and re-run (Tile never auto-installs):");
+        for (const c of failed) (0, import_core11.hint)(`  \u2022 ${c.name} \u2014 ${c.fix}`);
+        throw new import_core11.TileError(
+          `preflight failed: ${failed.map((c) => c.name).join(", ")}`,
+          import_core11.ExitCode.ERROR
+        );
+      }
+      ensureDevice(opts);
+      if (opts.apk) {
+        if (opts.build) throw new import_core11.TileError("--apk and --build are mutually exclusive.", import_core11.ExitCode.USAGE);
+        const apk = path10.resolve(opts.apk);
+        if (apk.toLowerCase().endsWith(".aab")) {
+          throw new import_core11.TileError(
+            "an .aab cannot be installed on a device directly (Play expands it server-side).",
+            import_core11.ExitCode.USAGE,
+            "Make an installable APK first: bundletool build-apks --mode=universal \u2026 then pass that .apk. (Native --aab support is planned.)"
+          );
+        }
+        if (!fs7.existsSync(apk)) throw new import_core11.TileError(`APK not found: ${apk}`, import_core11.ExitCode.NOT_FOUND);
+        installApk(apk, opts.device);
+      } else {
+        const pkg = appPackage(root);
+        const needBuild = !!opts.build || pkg !== null && !isInstalled(pkg);
+        if (needBuild) {
+          if (!opts.build && pkg) (0, import_core11.info)(`\u25B8 app ${pkg} not installed \u2014 building\u2026`);
+          buildAndInstallAndroid(root, opts.device);
+        }
+      }
+      const margs = [];
+      if (opts.device) margs.push("--device", opts.device);
+      margs.push("test", flowsDir);
+      (0, import_core11.info)(`\u25B8 maestro ${margs.join(" ")}`);
+      const r = (0, import_child_process5.spawnSync)("maestro", margs, { stdio: "inherit", cwd: root });
+      if (r.status === 0) {
+        if ((0, import_core11.isJsonMode)()) (0, import_core11.out)({ ok: true, flows: relFlows });
+        else (0, import_core11.hint)("", "\u2713 tests passed.");
+        return;
+      }
+      if ((0, import_core11.isJsonMode)()) (0, import_core11.out)({ ok: false, stage: "tests", flows: relFlows });
+      throw new import_core11.TileError("tests failed.", import_core11.ExitCode.ERROR, "See the Maestro output above for the failing step.");
+    }
+  );
+  const mark = (s) => s === "passed" ? "\u2713" : s === "failed" ? "\u2717" : "\u2013";
+  test.command("run <buildId>").description("Trigger a CLOUD test run of a finished build (boots a real emulator, runs the flows).").option("--platform <p>", "android (ios later)", "android").option("--app <appId>", "app id (or tile.json / TILE_APP)").action(async (buildId, opts) => {
+    const app = (0, import_core11.resolveApp)(opts);
+    const { test: t } = await (0, import_core11.createTest)(app, { buildId, platform: opts.platform });
+    if ((0, import_core11.isJsonMode)()) {
+      (0, import_core11.out)(t);
+      return;
+    }
+    (0, import_core11.info)(`\u2713 test queued \u2014 ${t.id}  (build ${buildId})`);
+    (0, import_core11.hint)(`Check the verdict: \`tile test status ${t.id}\``);
+  });
+  test.command("status <id>").description("Show a cloud test run\u2019s verdict (pass/fail) and what happened (lint/install/flows).").action(async (id) => {
+    const { test: t, artifactsUrl } = await (0, import_core11.getTest)(id);
+    if ((0, import_core11.isJsonMode)()) {
+      (0, import_core11.out)({ test: t, artifactsUrl });
+      return;
+    }
+    const verdict = t.result ? t.result === "passed" ? "\u2713 PASSED" : "\u2717 FAILED" : t.status;
+    (0, import_core11.info)(`${t.id}  ${verdict}`);
+    if (t.buildId) (0, import_core11.info)(`  build: ${t.buildId}`);
+    (0, import_core11.info)(`  run:   ${t.status}`);
+    const g = t.gates || {};
+    (0, import_core11.info)(`  gates: lint ${mark(g.lint)}   install ${mark(g.install)}   flows ${mark(g.flows)}`);
+    if (t.flowsTotal != null) {
+      (0, import_core11.info)(`  flows: ${t.flowsTotal - (t.flowsFailed ?? 0)}/${t.flowsTotal} passed`);
+    }
+    if (t.error) (0, import_core11.info)(`  error: ${typeof t.error === "string" ? t.error : JSON.stringify(t.error)}`);
+    if (t.status === "finished" && t.result === "failed" && artifactsUrl) {
+      (0, import_core11.hint)(`Failing-step screenshots + JUnit report: ${artifactsUrl}`);
+    } else if (!(0, import_core11.isTerminalStatus)(t.status)) {
+      (0, import_core11.hint)(`Still running \u2014 re-run \`tile test status ${id}\` in a moment.`);
+    }
+  });
+  test.command("list [buildId]").description("List recent cloud test runs (newest first). Pass a buildId to filter to one build.").option("--app <appId>", "app id (or tile.json / TILE_APP)").option("--platform <p>", "only test runs for this platform (android|ios)").action(async (buildId, opts) => {
+    const app = (0, import_core11.resolveApp)(opts);
+    let tests = await (0, import_core11.listTests)(app);
+    if (buildId) tests = tests.filter((t) => t.buildId === buildId);
+    if (opts.platform) tests = tests.filter((t) => (t.platform ?? "android") === opts.platform);
+    if ((0, import_core11.isJsonMode)()) {
+      (0, import_core11.out)({ tests });
+      return;
+    }
+    if (!tests.length) {
+      (0, import_core11.info)(buildId ? `No test runs for build ${buildId}.` : "No test runs yet.");
+      return;
+    }
+    for (const t of tests) {
+      const verdict = t.result ? t.result.toUpperCase() : "-";
+      (0, import_core11.info)(`${t.id}  ${t.status.padEnd(12)} ${verdict.padEnd(7)} build=${t.buildId ?? "-"}  ${t.createdAt ?? ""}`);
+    }
+  });
+  test.command("cancel <id>").description("Cancel an in-progress cloud test run (tears down the runner VM).").action(async (id) => {
+    const { test: t } = await (0, import_core11.cancelTest)(id);
+    if ((0, import_core11.isJsonMode)()) (0, import_core11.out)(t);
+    else (0, import_core11.info)(`\u2713 Cancel requested \u2014 ${t.id} is now ${t.status}.`);
+  });
+}
+
+// src/index.ts
+var program = new import_commander2.Command();
+program.name("tile").description("Tile \u2014 unified CLI for Tile apps (source, builds, OTA).").version(require_package().version, "-v, --version").option("--json", "machine-readable JSON output on stdout; suppresses hints").showHelpAfterError("(add --help for usage)");
+program.hook("preAction", (thisCommand) => {
+  if (thisCommand.opts().json) (0, import_core12.setJsonMode)(true);
+});
+registerAuthCommands(program);
+registerLiveLayerCommands(program);
+registerBuildCommands(program);
+registerMetaCommands(program);
+registerAppCommands(program);
+registerSourceCommands(program);
+registerDevCommands(program);
+registerPreviewCommands(program);
+registerGithubCommands(program);
+registerIntegrationsCommands(program);
+registerAssetCommands(program);
+registerTestCommands(program);
+registerOtaCommands(program);
+program.action(() => {
+  (0, import_core12.info)("tile \u2014 unified CLI for Tile apps (Expo/React Native).");
+  (0, import_core12.info)("");
+  (0, import_core12.info)("  tile guide            what Tile is + the full lifecycle");
+  (0, import_core12.info)("  tile status           where you are + the suggested next command");
+  (0, import_core12.info)("  tile register/login   create an account \xB7 authenticate (or set TILE_TOKEN)");
+  (0, import_core12.info)("  tile app / use        create, list, select apps");
+  (0, import_core12.info)("  tile init / save      scaffold locally \xB7 store a new version");
+  (0, import_core12.info)("  tile build ...        native builds");
+  (0, import_core12.info)("  tile integrations ... connect Supabase/Shopify/custom (powers the AI agent)");
+  (0, import_core12.info)("");
+  (0, import_core12.info)("New here? Run `tile guide`. Run `tile <command> --help` for details; add --json to parse output.");
+});
+async function main() {
+  const raw = process.argv.slice(2);
+  if (raw[0] === "ota") {
+    const otaArgs = raw.slice(1);
+    const wantsHelp = otaArgs.length === 0 || otaArgs.includes("--help") || otaArgs.includes("-h");
+    if (!wantsHelp) runOtaIntercept(otaArgs);
+  }
+  await program.parseAsync(process.argv);
+}
+main().catch((err) => {
+  if (err instanceof import_core12.TileError) {
+    if ((0, import_core12.isJsonMode)()) {
+      (0, import_core12.out)({ error: err.message, ...err.nextStep ? { nextStep: err.nextStep } : {} });
+    } else {
+      process.stderr.write(`error: ${err.message}
+`);
+      if (err.nextStep) (0, import_core12.hint)(`Next: ${err.nextStep}`);
+    }
+    process.exit(err.exitCode);
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  if ((0, import_core12.isJsonMode)()) {
+    (0, import_core12.out)({ error: message });
+  } else {
+    process.stderr.write(`error: ${message}
+`);
+  }
+  process.exit(import_core12.ExitCode.ERROR);
+});