@construct-space/cli 1.9.4 → 1.9.6

package/dist/index.js

@@ -2790,8 +2790,8 @@ var require_lib = __commonJS((exports, module) => {
 });
 
 // src/lib/appdir.ts
-import { existsSync as existsSync8, readFileSync as readFileSync6 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync6 } from "fs";
+import { join as join11 } from "path";
 import { homedir } from "os";
 import { platform } from "process";
 function dataDir() {
@@ -2800,32 +2800,32 @@ function dataDir() {
   const home = homedir();
   switch (platform) {
     case "darwin":
-      return join10(home, "Library", "Application Support", "Construct");
+      return join11(home, "Library", "Application Support", "Construct");
     case "win32": {
-      const appData = process.env.APPDATA || join10(home, "AppData", "Roaming");
-      return join10(appData, "Construct");
+      const appData = process.env.APPDATA || join11(home, "AppData", "Roaming");
+      return join11(appData, "Construct");
     }
     default: {
-      const xdg = process.env.XDG_DATA_HOME || join10(home, ".local", "share");
-      return join10(xdg, "construct");
+      const xdg = process.env.XDG_DATA_HOME || join11(home, ".local", "share");
+      return join11(xdg, "construct");
     }
   }
 }
 function profilesDir() {
-  return join10(dataDir(), "profiles");
+  return join11(dataDir(), "profiles");
 }
 function activeProfileId() {
   try {
-    const credsPath = join10(dataDir(), "credentials.json");
-    if (existsSync8(credsPath)) {
+    const credsPath = join11(dataDir(), "credentials.json");
+    if (existsSync9(credsPath)) {
       const c = JSON.parse(readFileSync6(credsPath, "utf-8"));
       if (c.profileId)
         return c.profileId;
     }
   } catch {}
   try {
-    const regPath = join10(dataDir(), "profiles.json");
-    if (existsSync8(regPath)) {
+    const regPath = join11(dataDir(), "profiles.json");
+    if (existsSync9(regPath)) {
       const r = JSON.parse(readFileSync6(regPath, "utf-8"));
       if (r.active_profile)
         return r.active_profile;
@@ -2836,29 +2836,29 @@ function activeProfileId() {
 function spacesDir() {
   const profileId = activeProfileId();
   if (profileId)
-    return join10(profilesDir(), profileId, "spaces");
-  return join10(dataDir(), "spaces");
+    return join11(profilesDir(), profileId, "spaces");
+  return join11(dataDir(), "spaces");
 }
 function spaceDir(spaceId) {
-  return join10(spacesDir(), spaceId);
+  return join11(spacesDir(), `${spaceId}.space`);
 }
 var init_appdir = () => {};
 
 // src/lib/auth.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, unlinkSync, existsSync as existsSync10, readdirSync as readdirSync5, statSync as statSync3 } from "fs";
-import { join as join12, dirname as dirname4 } from "path";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, mkdirSync as mkdirSync6, unlinkSync, existsSync as existsSync11, readdirSync as readdirSync5, statSync as statSync2 } from "fs";
+import { join as join13, dirname as dirname5 } from "path";
 function listDesktopProfiles() {
   const dir = profilesDir();
-  if (!existsSync10(dir))
+  if (!existsSync11(dir))
     return [];
   const results = [];
   for (const entry of readdirSync5(dir)) {
-    const full = join12(dir, entry);
+    const full = join13(dir, entry);
     try {
-      if (!statSync3(full).isDirectory())
+      if (!statSync2(full).isDirectory())
         continue;
-      const authPath = join12(full, "auth.json");
-      if (!existsSync10(authPath))
+      const authPath = join13(full, "auth.json");
+      if (!existsSync11(authPath))
         continue;
       const data = JSON.parse(readFileSync7(authPath, "utf-8"));
       if (!data.token)
@@ -2877,14 +2877,14 @@ function listDesktopProfiles() {
   return results;
 }
 function legacyCredentialsPath() {
-  return join12(dataDir(), LEGACY_CREDENTIALS_FILE);
+  return join13(dataDir(), LEGACY_CREDENTIALS_FILE);
 }
 function registryPath() {
-  return join12(dataDir(), PROFILES_REGISTRY);
+  return join13(dataDir(), PROFILES_REGISTRY);
 }
 function readRegistry() {
   const path = registryPath();
-  if (!existsSync10(path))
+  if (!existsSync11(path))
     return {};
   try {
     return JSON.parse(readFileSync7(path, "utf-8"));
@@ -2894,7 +2894,7 @@ function readRegistry() {
 }
 function writeRegistry(reg) {
   const path = registryPath();
-  mkdirSync4(dirname4(path), { recursive: true });
+  mkdirSync6(dirname5(path), { recursive: true });
   writeFileSync5(path, JSON.stringify({ version: 1, ...reg }, null, 2));
 }
 function store(creds) {
@@ -2902,10 +2902,10 @@ function store(creds) {
   if (!profileId) {
     throw new Error("cannot store credentials without a profile id (user.id or profileId)");
   }
-  const profilePath = join12(profilesDir(), profileId, "auth.json");
-  mkdirSync4(dirname4(profilePath), { recursive: true });
+  const profilePath = join13(profilesDir(), profileId, "auth.json");
+  mkdirSync6(dirname5(profilePath), { recursive: true });
   let existing = {};
-  if (existsSync10(profilePath)) {
+  if (existsSync11(profilePath)) {
     try {
       existing = JSON.parse(readFileSync7(profilePath, "utf-8"));
     } catch {}
@@ -2945,7 +2945,7 @@ function store(creds) {
 }
 function migrateLegacyCredentials() {
   const legacy = legacyCredentialsPath();
-  if (!existsSync10(legacy))
+  if (!existsSync11(legacy))
     return;
   try {
     const data = JSON.parse(readFileSync7(legacy, "utf-8"));
@@ -2954,8 +2954,8 @@ function migrateLegacyCredentials() {
     const pid = data.profileId || data.user?.id;
     if (!pid)
       return;
-    const profilePath = join12(profilesDir(), pid, "auth.json");
-    if (existsSync10(profilePath))
+    const profilePath = join13(profilesDir(), pid, "auth.json");
+    if (existsSync11(profilePath))
       return;
     store({ ...data, profileId: pid });
   } catch {}
@@ -2969,15 +2969,15 @@ function load2() {
 }
 function loadFromActiveProfile() {
   try {
-    const regPath = join12(dataDir(), "profiles.json");
-    if (!existsSync10(regPath))
+    const regPath = join13(dataDir(), "profiles.json");
+    if (!existsSync11(regPath))
       return null;
     const reg = JSON.parse(readFileSync7(regPath, "utf-8"));
     const activeId = reg.active_profile;
     if (!activeId)
       return null;
-    const authPath = join12(profilesDir(), activeId, "auth.json");
-    if (!existsSync10(authPath))
+    const authPath = join13(profilesDir(), activeId, "auth.json");
+    if (!existsSync11(authPath))
       return null;
     const a = JSON.parse(readFileSync7(authPath, "utf-8"));
     if (!a.token)
@@ -3014,8 +3014,8 @@ function clear() {
   const reg = readRegistry();
   const activeId = reg.active_profile;
   if (activeId) {
-    const profilePath = join12(profilesDir(), activeId, "auth.json");
-    if (existsSync10(profilePath)) {
+    const profilePath = join13(profilesDir(), activeId, "auth.json");
+    if (existsSync11(profilePath)) {
       try {
         const data = JSON.parse(readFileSync7(profilePath, "utf-8"));
         data.authenticated = false;
@@ -3025,7 +3025,7 @@ function clear() {
     }
   }
   const legacy = legacyCredentialsPath();
-  if (existsSync10(legacy))
+  if (existsSync11(legacy))
     unlinkSync(legacy);
 }
 var LEGACY_CREDENTIALS_FILE = "credentials.json", PROFILES_REGISTRY = "profiles.json", DEFAULT_PORTAL = "https://my.construct.space/api/developer";
@@ -3190,7 +3190,7 @@ function loadCreds() {
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     throw new Error(msg + `
-Run 'construct login' first.`);
+Run 'construct login' first.`, { cause: err });
   }
 }
 async function graphRequest(opts) {
@@ -5453,6 +5453,8 @@ async function scaffold(nameArg, options) {
     join2(name, "scripts"),
     join2(name, "references"),
     join2(name, "assets"),
+    join2(name, "tools"),
+    join2(name, "lib"),
     join2(name, "agent", "hooks"),
     join2(name, "agent", "tools"),
     join2(name, "widgets", "summary")
@@ -5516,9 +5518,9 @@ async function scaffold(nameArg, options) {
 
 // src/commands/build.ts
 init_source();
-import { cpSync, existsSync as existsSync6, readFileSync as readFileSync4, readdirSync as readdirSync3, renameSync, statSync as statSync2 } from "fs";
-import { join as join6 } from "path";
-import { createHash } from "crypto";
+import { existsSync as existsSync7, readFileSync as readFileSync4, readdirSync as readdirSync3, renameSync, rmSync as rmSync2 } from "fs";
+import { join as join7 } from "path";
+import { createHash as createHash2 } from "crypto";
 
 // node_modules/ora/index.js
 init_source();
@@ -8154,6 +8156,7 @@ function ora(options) {
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync3 } from "fs";
 import { join as join3 } from "path";
 var MANIFEST_FILE = "space.manifest.json";
+var HOST_API_VERSION = "0.6.0";
 var idRegex = /^[a-z][a-z0-9-]*$/;
 var versionRegex = /^\d+\.\d+\.\d+/;
 function validate2(m) {
@@ -8247,7 +8250,7 @@ function scanPagesDir(pagesDir) {
 function varNameFromFile(filePath) {
   let cleaned = filePath.replace(/^pages\//, "").replace(/\.vue$/, "");
   cleaned = cleaned.replace(/\[([^\]]+)\]/g, "$1");
-  const segments = cleaned.split(/[\/-]/).filter(Boolean);
+  const segments = cleaned.split(/[/-]/).filter(Boolean);
   const name = segments.map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
   return (name || "Index") + "Page";
 }
@@ -8261,11 +8264,11 @@ function resolvePages(m, root, prefix) {
   return m.pages.map((p) => {
     if (p.component) {
       const base = basename(p.component);
-      const nameWithoutExt = base.replace(extname(base), "").replace(/[\[\]]/g, "");
+      const nameWithoutExt = base.replace(extname(base), "").replace(/[[\]]/g, "");
       const dir = p.component.replace(/^pages\//, "").replace(/\/[^/]+$/, "");
       let varName;
       if (dir && dir !== p.component.replace(/^pages\//, "")) {
-        varName = capitalize(dir.split("/").map((s) => s.replace(/[\[\]]/g, "")).join("-")) + capitalize(nameWithoutExt) + "Page";
+        varName = capitalize(dir.split("/").map((s) => s.replace(/[[\]]/g, "")).join("-")) + capitalize(nameWithoutExt) + "Page";
       } else {
         varName = capitalize(nameWithoutExt) + "Page";
       }
@@ -8281,7 +8284,7 @@ function resolvePages(m, root, prefix) {
     if (existsSync4(legacyFullPath)) {
       let varName = "IndexPage";
       if (p.path) {
-        varName = capitalize(p.path.replace(/\[([^\]]+)\]/g, "$1").replace(/[\/:]/g, "-").replace(/-+/g, "-")) + "Page";
+        varName = capitalize(p.path.replace(/\[([^\]]+)\]/g, "$1").replace(/[/:]/g, "-").replace(/-+/g, "-")) + "Page";
       }
       return { varName, importPath: prefix + legacyComponent, path: p.path };
     }
@@ -8362,74 +8365,216 @@ function writeEntry(root, m) {
   writeFileSync3(join4(srcDir, "entry.ts"), generate(root, m));
 }
 
-// src/lib/agent.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync4, readdirSync as readdirSync2, existsSync as existsSync5 } from "fs";
-import { join as join5, extname as extname2, basename as basename2 } from "path";
-var AGENT_KEY = "construct-agent-obfuscate-v1";
-function encode(content) {
-  const key = Buffer.from(AGENT_KEY);
-  const data = Buffer.from(content);
-  const xored = Buffer.alloc(data.length);
-  for (let i = 0;i < data.length; i++) {
-    xored[i] = data[i] ^ key[i % key.length];
-  }
-  return xored.toString("base64");
-}
-function readMdFiles(dir) {
-  const result = {};
-  if (!existsSync5(dir))
-    return result;
-  for (const f of readdirSync2(dir)) {
-    if (extname2(f) !== ".md")
+// src/lib/spaceBundle.ts
+import { createHash } from "crypto";
+import { cpSync, existsSync as existsSync5, lstatSync, mkdirSync as mkdirSync3, readFileSync as readFileSync3, readdirSync as readdirSync2, rmSync, writeFileSync as writeFileSync4 } from "fs";
+import { basename as basename2, dirname as dirname2, join as join5, relative as relative2 } from "path";
+var BUNDLE_DIRS = ["agent", "scripts", "references", "assets", "icons", "media", "public", "tools", "lib"];
+var BUNDLE_FILES = ["SKILL.md"];
+function stageSpaceResources(root, distDir) {
+  const copied = [];
+  for (const name of BUNDLE_DIRS) {
+    rmSync(join5(distDir, name), { recursive: true, force: true });
+    const src = join5(root, name);
+    if (!existsSync5(src) || !lstatSync(src).isDirectory())
       continue;
-    result[basename2(f, ".md")] = readFileSync3(join5(dir, f), "utf-8");
+    cpSync(src, join5(distDir, name), { recursive: true, verbatimSymlinks: true });
+    copied.push(name);
   }
-  return result;
+  for (const name of BUNDLE_FILES) {
+    rmSync(join5(distDir, name), { recursive: true, force: true });
+    const src = join5(root, name);
+    if (!existsSync5(src) || !lstatSync(src).isFile())
+      continue;
+    cpSync(src, join5(distDir, name), { verbatimSymlinks: true });
+    copied.push(name);
+  }
+  return copied;
 }
-function readJsonFiles(dir) {
-  const result = {};
-  if (!existsSync5(dir))
-    return result;
-  for (const f of readdirSync2(dir)) {
-    if (extname2(f) !== ".json")
+function slashPath(path) {
+  return path.replace(/\\/g, "/");
+}
+function copyFileIntoBundle(src, dst) {
+  mkdirSync3(dirname2(dst), { recursive: true });
+  cpSync(src, dst, { verbatimSymlinks: true });
+}
+function collectFiles(root) {
+  const files = [];
+  function walk(dir) {
+    for (const name of readdirSync2(dir).sort()) {
+      const path = join5(dir, name);
+      const stat = lstatSync(path);
+      if (stat.isSymbolicLink())
+        continue;
+      if (stat.isDirectory()) {
+        walk(path);
+      } else if (stat.isFile()) {
+        files.push(slashPath(relative2(root, path)));
+      }
+    }
+  }
+  walk(root);
+  return files;
+}
+function sha256(path) {
+  return createHash("sha256").update(readFileSync3(path)).digest("hex");
+}
+function writeChecksums(spaceDir, spaceId) {
+  const files = collectFiles(spaceDir).filter((file) => file !== "checksums.json");
+  const checksums = {};
+  for (const file of files) {
+    checksums[file] = sha256(join5(spaceDir, file));
+  }
+  writeFileSync4(join5(spaceDir, "checksums.json"), JSON.stringify({
+    format: "construct.space/v1",
+    id: spaceId,
+    files: checksums
+  }, null, 2) + `
+`);
+  return collectFiles(spaceDir);
+}
+function createSpaceBundle(options) {
+  const spaceDir = join5(options.distDir, `${options.spaceId}.space`);
+  const appName = basename2(options.appBundlePath);
+  const cssName = options.cssPath ? basename2(options.cssPath) : "";
+  rmSync(spaceDir, { recursive: true, force: true });
+  mkdirSync3(spaceDir, { recursive: true });
+  copyFileIntoBundle(join5(options.distDir, "manifest.json"), join5(spaceDir, "manifest.json"));
+  copyFileIntoBundle(options.appBundlePath, join5(spaceDir, "app.iife.js"));
+  const hasStyle = Boolean(options.cssPath && existsSync5(options.cssPath));
+  if (hasStyle && options.cssPath) {
+    copyFileIntoBundle(options.cssPath, join5(spaceDir, "style.css"));
+  }
+  for (const entry of readdirSync2(options.distDir)) {
+    if (entry === `${options.spaceId}.space`)
+      continue;
+    if (entry.endsWith(".space"))
       continue;
-    result[basename2(f, ".json")] = readFileSync3(join5(dir, f), "utf-8");
+    if (entry === "manifest.json")
+      continue;
+    if (entry === appName || entry === cssName)
+      continue;
+    if (entry.endsWith(".iife.js") || entry.endsWith(".css"))
+      continue;
+    cpSync(join5(options.distDir, entry), join5(spaceDir, entry), {
+      recursive: true,
+      verbatimSymlinks: true
+    });
   }
-  return result;
+  return {
+    dir: spaceDir,
+    hasStyle,
+    files: writeChecksums(spaceDir, options.spaceId)
+  };
 }
-function bundleAgentDir(srcDir, distDir) {
-  const bundle = {
-    config: "",
-    tools: readMdFiles(join5(srcDir, "tools")),
-    skills: readMdFiles(join5(srcDir, "skills")),
-    hooks: readJsonFiles(join5(srcDir, "hooks"))
+
+// src/lib/spaceTools.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync4 } from "fs";
+import { join as join6 } from "path";
+import { arch as nodeArch, platform as nodePlatform } from "process";
+import { spawnSync } from "child_process";
+var SPACE_TOOL_TARGETS = [
+  "darwin-arm64",
+  "darwin-x64",
+  "linux-arm64",
+  "linux-x64",
+  "windows-arm64",
+  "windows-x64"
+];
+var GO_TARGETS = {
+  "darwin-arm64": { goos: "darwin", goarch: "arm64", ext: "" },
+  "darwin-x64": { goos: "darwin", goarch: "amd64", ext: "" },
+  "linux-arm64": { goos: "linux", goarch: "arm64", ext: "" },
+  "linux-x64": { goos: "linux", goarch: "amd64", ext: "" },
+  "windows-arm64": { goos: "windows", goarch: "arm64", ext: ".exe" },
+  "windows-x64": { goos: "windows", goarch: "amd64", ext: ".exe" }
+};
+function isSpaceToolTarget(value) {
+  return SPACE_TOOL_TARGETS.includes(value);
+}
+function currentSpaceToolTarget(platform = nodePlatform, arch = nodeArch) {
+  if (platform === "darwin" && arch === "arm64")
+    return "darwin-arm64";
+  if (platform === "darwin" && arch === "x64")
+    return "darwin-x64";
+  if (platform === "linux" && arch === "arm64")
+    return "linux-arm64";
+  if (platform === "linux" && arch === "x64")
+    return "linux-x64";
+  if (platform === "win32" && arch === "arm64")
+    return "windows-arm64";
+  if (platform === "win32" && arch === "x64")
+    return "windows-x64";
+  return null;
+}
+function parseSpaceToolTargets(value = process.env.CONSTRUCT_TOOL_TARGETS) {
+  const raw = value?.trim();
+  if (!raw) {
+    const current = currentSpaceToolTarget();
+    if (!current)
+      throw new Error(`Unsupported tool build platform: ${nodePlatform}-${nodeArch}`);
+    return [current];
+  }
+  if (raw === "all")
+    return [...SPACE_TOOL_TARGETS];
+  const targets = raw.split(/[,\s]+/).filter(Boolean);
+  const invalid = targets.filter((target) => !isSpaceToolTarget(target));
+  if (invalid.length > 0) {
+    throw new Error(`Invalid CONSTRUCT_TOOL_TARGETS value: ${invalid.join(", ")}. ` + `Expected one or more of: ${SPACE_TOOL_TARGETS.join(", ")}, or "all".`);
+  }
+  return Array.from(new Set(targets));
+}
+function defaultRunner(invocation) {
+  const result = spawnSync("go", invocation.args, {
+    cwd: invocation.root,
+    env: invocation.env,
+    encoding: "utf-8"
+  });
+  return {
+    status: result.status,
+    stdout: result.stdout || "",
+    stderr: result.stderr || "",
+    error: result.error
   };
-  for (const name of ["config.md", "agent.md"]) {
-    const path = join5(srcDir, name);
-    if (existsSync5(path)) {
-      bundle.config = readFileSync3(path, "utf-8");
-      break;
+}
+function buildSpaceTools(root, distDir, spaceId, options = {}) {
+  const sourcePath = join6(root, "tools.go");
+  if (!existsSync6(sourcePath))
+    return [];
+  const built = [];
+  const targets = options.targets ?? parseSpaceToolTargets(options.env?.CONSTRUCT_TOOL_TARGETS);
+  const runner = options.runner ?? defaultRunner;
+  for (const target of targets) {
+    const goTarget = GO_TARGETS[target];
+    const outputDir = join6(distDir, "tools", target);
+    const outputName = `${spaceId}-tools${goTarget.ext}`;
+    const outputPath = join6(outputDir, outputName);
+    mkdirSync4(outputDir, { recursive: true });
+    const env2 = {
+      ...process.env,
+      ...options.env,
+      GOOS: goTarget.goos,
+      GOARCH: goTarget.goarch
+    };
+    if (!env2.CGO_ENABLED)
+      env2.CGO_ENABLED = "0";
+    const args = ["build", "-trimpath", "-o", outputPath, "./tools.go"];
+    const result = runner({ root, target, outputPath, args, env: env2 });
+    if (result.error) {
+      throw new Error(`Failed to build tools.go for ${target}: ${result.error.message}`);
+    }
+    if (result.status !== 0) {
+      const details = [result.stderr, result.stdout].filter(Boolean).join(`
+`).trim();
+      throw new Error(`Failed to build tools.go for ${target}${details ? `:
+${details}` : ""}`);
     }
+    built.push(`tools/${target}/${outputName}`);
   }
-  if (!bundle.config)
-    return;
-  const encoded = encode(JSON.stringify(bundle));
-  writeFileSync4(join5(distDir, "config.agent"), encoded);
+  return built;
 }
 
 // src/commands/build.ts
-var ASSET_DIRS = ["icons", "assets", "media", "public", "bin"];
-function copyAssetDirs(root, distDir) {
-  const copied = [];
-  for (const name of ASSET_DIRS) {
-    const src = join6(root, name);
-    if (!existsSync6(src) || !statSync2(src).isDirectory())
-      continue;
-    cpSync(src, join6(distDir, name), { recursive: true, verbatimSymlinks: true });
-    copied.push(name);
-  }
-  return copied;
-}
 function stripTsComments(source) {
   let out = "";
   let i = 0;
@@ -8518,7 +8663,7 @@ function readObjectEntries(source) {
       i += 1;
     if (i >= source.length)
       break;
-    let key = "";
+    let key;
     const quote = source[i];
     if (quote === '"' || quote === "'" || quote === "`") {
       i += 1;
@@ -8629,41 +8774,52 @@ async function build(options) {
     process.exit(1);
   }
   runHook(m.hooks, "postBuild", root);
-  const agentDir = join6(root, "agent");
-  if (existsSync6(agentDir) && statSync2(agentDir).isDirectory()) {
-    const distDir2 = join6(root, "dist");
-    bundleAgentDir(agentDir, distDir2);
-    bundleAgentDir(agentDir, root);
+  const copiedResources = stageSpaceResources(root, join7(root, "dist"));
+  if (copiedResources.length > 0) {
+    console.log(source_default.blue(`  Resources: ${copiedResources.join(", ")}`));
   }
-  const copiedAssetDirs = copyAssetDirs(root, join6(root, "dist"));
-  if (copiedAssetDirs.length > 0) {
-    console.log(source_default.blue(`  Assets: ${copiedAssetDirs.join(", ")}`));
+  try {
+    const builtTools = buildSpaceTools(root, join7(root, "dist"), m.id);
+    if (builtTools.length > 0) {
+      console.log(source_default.blue(`  Tools: ${builtTools.join(", ")}`));
+    }
+  } catch (err) {
+    console.error(source_default.red(err?.message || String(err)));
+    process.exit(1);
   }
-  const distDir = join6(root, "dist");
+  const distDir = join7(root, "dist");
   const expectedBundle = `space-${m.id}.iife.js`;
-  let bundlePath = join6(distDir, expectedBundle);
-  if (!existsSync6(bundlePath)) {
+  const bundlePath = join7(distDir, expectedBundle);
+  if (!existsSync7(bundlePath)) {
     const matches = readdirSync3(distDir).filter((f) => f.startsWith("space-") && f.endsWith(".iife.js"));
     if (matches.length === 1) {
-      renameSync(join6(distDir, matches[0]), bundlePath);
-      const oldCSS = join6(distDir, matches[0].replace(".iife.js", ".css"));
-      const newCSS = join6(distDir, `space-${m.id}.css`);
-      if (existsSync6(oldCSS))
+      renameSync(join7(distDir, matches[0]), bundlePath);
+      const oldCSS = join7(distDir, matches[0].replace(".iife.js", ".css"));
+      const newCSS = join7(distDir, `space-${m.id}.css`);
+      if (existsSync7(oldCSS))
         renameSync(oldCSS, newCSS);
     }
   }
-  const expectedCSS = join6(distDir, `space-${m.id}.css`);
-  if (!existsSync6(expectedCSS)) {
+  if (!existsSync7(bundlePath)) {
+    console.error(source_default.red(`Build did not emit ${expectedBundle}`));
+    process.exit(1);
+  }
+  const expectedCSS = join7(distDir, `space-${m.id}.css`);
+  if (!existsSync7(expectedCSS)) {
     const cssMatches = readdirSync3(distDir).filter((f) => f.endsWith(".css"));
     const renamedCSS = cssMatches.find((f) => f.startsWith("space-")) || (cssMatches.length === 1 ? cssMatches[0] : undefined);
     if (renamedCSS)
-      renameSync(join6(distDir, renamedCSS), expectedCSS);
+      renameSync(join7(distDir, renamedCSS), expectedCSS);
+  }
+  if (!existsSync7(expectedCSS)) {
+    console.error(source_default.red(`Build did not emit CSS. Spaces must import src/style.css so pages and widgets are self-contained.`));
+    process.exit(1);
   }
   const bundleData = readFileSync4(bundlePath);
-  const checksum = createHash("sha256").update(bundleData).digest("hex");
+  const checksum = createHash2("sha256").update(bundleData).digest("hex");
   const raw = readRaw(root);
-  const actionsPath = join6(root, "src", "actions.ts");
-  if (existsSync6(actionsPath)) {
+  const actionsPath = join7(root, "src", "actions.ts");
+  if (existsSync7(actionsPath)) {
     const actionMeta = extractActionMetadata(actionsPath);
     if (actionMeta && Object.keys(actionMeta).length > 0) {
       raw.actions = actionMeta;
@@ -8673,28 +8829,40 @@ async function build(options) {
   writeWithBuild(distDir, raw, {
     checksum,
     size: bundleData.length,
-    hostApiVersion: "0.5.0",
+    hostApiVersion: HOST_API_VERSION,
     builtAt: new Date().toISOString()
   });
-  console.log(source_default.green(`Built ${m.name} v${m.version}`));
+  const spaceBundle = createSpaceBundle({
+    distDir,
+    spaceId: m.id,
+    appBundlePath: bundlePath,
+    cssPath: expectedCSS
+  });
+  for (const entry of readdirSync3(distDir)) {
+    if (entry === `${m.id}.space`)
+      continue;
+    rmSync2(join7(distDir, entry), { recursive: true, force: true });
+  }
+  console.log(source_default.green(`Built ${m.name} v${m.version} -> dist/${m.id}.space`));
+  console.log(source_default.dim(`  ${spaceBundle.files.length} files, ${spaceBundle.hasStyle ? "style.css included" : "no style.css"}`));
 }
 
 // src/commands/dev.ts
 init_source();
-import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
-import { join as join9 } from "path";
-import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync8, readFileSync as readFileSync5 } from "fs";
+import { join as join10 } from "path";
+import { createHash as createHash3 } from "crypto";
 
-// node_modules/chokidar/esm/index.js
-import { stat as statcb } from "fs";
-import { stat as stat3, readdir as readdir2 } from "fs/promises";
+// node_modules/chokidar/index.js
 import { EventEmitter } from "events";
-import * as sysPath2 from "path";
+import { stat as statcb, Stats } from "fs";
+import { readdir as readdir2, stat as stat3 } from "fs/promises";
+import * as sp2 from "path";
 
-// node_modules/readdirp/esm/index.js
-import { stat, lstat, readdir, realpath } from "fs/promises";
+// node_modules/readdirp/index.js
+import { lstat, readdir, realpath, stat } from "fs/promises";
+import { join as pjoin, relative as prelative, resolve as presolve, sep as psep } from "path";
 import { Readable } from "stream";
-import { resolve as presolve, relative as prelative, join as pjoin, sep as psep } from "path";
 var EntryTypes = {
   FILE_TYPE: "files",
   DIR_TYPE: "directories",
@@ -8750,6 +8918,20 @@ var normalizeFilter = (filter) => {
 };
 
 class ReaddirpStream extends Readable {
+  parents;
+  reading;
+  parent;
+  _stat;
+  _maxDepth;
+  _wantsDir;
+  _wantsFile;
+  _wantsEverything;
+  _root;
+  _isDirent;
+  _statsProp;
+  _rdOptions;
+  _fileFilter;
+  _directoryFilter;
   constructor(options = {}) {
     super({
       objectMode: true,
@@ -8766,7 +8948,7 @@ class ReaddirpStream extends Readable {
     } else {
       this._stat = statMethod;
     }
-    this._maxDepth = opts.depth ?? defaultOptions.depth;
+    this._maxDepth = opts.depth != null && Number.isSafeInteger(opts.depth) ? opts.depth : defaultOptions.depth;
     this._wantsDir = type ? DIR_TYPES.has(type) : false;
     this._wantsFile = type ? FILE_TYPES.has(type) : false;
     this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
@@ -8911,11 +9093,11 @@ function readdirp(root, options = {}) {
   return new ReaddirpStream(options);
 }
 
-// node_modules/chokidar/esm/handler.js
-import { watchFile, unwatchFile, watch as fs_watch } from "fs";
-import { open, stat as stat2, lstat as lstat2, realpath as fsrealpath } from "fs/promises";
-import * as sysPath from "path";
+// node_modules/chokidar/handler.js
+import { watch as fs_watch, unwatchFile, watchFile } from "fs";
+import { realpath as fsrealpath, lstat as lstat2, open, stat as stat2 } from "fs/promises";
 import { type as osType } from "os";
+import * as sp from "path";
 var STR_DATA = "data";
 var STR_END = "end";
 var STR_CLOSE = "close";
@@ -9207,7 +9389,7 @@ var binaryExtensions = new Set([
   "zip",
   "zipx"
 ]);
-var isBinaryPath = (filePath) => binaryExtensions.has(sysPath.extname(filePath).slice(1).toLowerCase());
+var isBinaryPath = (filePath) => binaryExtensions.has(sp.extname(filePath).slice(1).toLowerCase());
 var foreach = (val, fn) => {
   if (val instanceof Set) {
     val.forEach(fn);
@@ -9245,7 +9427,7 @@ function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
     listener(path);
     emitRaw(rawEvent, evPath, { watchedPath: path });
     if (evPath && path !== evPath) {
-      fsWatchBroadcast(sysPath.resolve(path, evPath), KEY_LISTENERS, sysPath.join(path, evPath));
+      fsWatchBroadcast(sp.resolve(path, evPath), KEY_LISTENERS, sp.join(path, evPath));
     }
   };
   try {
@@ -9360,17 +9542,19 @@ var setFsWatchFileListener = (path, fullPath, options, handlers) => {
 };
 
 class NodeFsHandler {
+  fsw;
+  _boundHandleError;
   constructor(fsW) {
     this.fsw = fsW;
     this._boundHandleError = (error2) => fsW._handleError(error2);
   }
   _watchWithNodeFs(path, listener) {
     const opts = this.fsw.options;
-    const directory = sysPath.dirname(path);
-    const basename4 = sysPath.basename(path);
+    const directory = sp.dirname(path);
+    const basename4 = sp.basename(path);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename4);
-    const absolutePath = sysPath.resolve(path);
+    const absolutePath = sp.resolve(path);
     const options = {
       persistent: opts.persistent
     };
@@ -9397,9 +9581,9 @@ class NodeFsHandler {
     if (this.fsw.closed) {
       return;
     }
-    const dirname3 = sysPath.dirname(file);
-    const basename4 = sysPath.basename(file);
-    const parent = this.fsw._getWatchedDir(dirname3);
+    const dirname4 = sp.dirname(file);
+    const basename4 = sp.basename(file);
+    const parent = this.fsw._getWatchedDir(dirname4);
     let prevStats = stats;
     if (parent.has(basename4))
       return;
@@ -9426,7 +9610,7 @@ class NodeFsHandler {
             prevStats = newStats2;
           }
         } catch (error2) {
-          this.fsw._remove(dirname3, basename4);
+          this.fsw._remove(dirname4, basename4);
         }
       } else if (parent.has(basename4)) {
         const at = newStats.atimeMs;
@@ -9481,8 +9665,9 @@ class NodeFsHandler {
     this.fsw._symlinkPaths.set(full, true);
   }
   _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
-    directory = sysPath.join(directory, "");
-    throttler = this.fsw._throttle("readdir", directory, 1000);
+    directory = sp.join(directory, "");
+    const throttleKey = target ? `${directory}:${target}` : directory;
+    throttler = this.fsw._throttle("readdir", throttleKey, 1000);
     if (!throttler)
       return;
     const previous = this.fsw._getWatchedDir(wh.path);
@@ -9499,7 +9684,7 @@ class NodeFsHandler {
         return;
       }
       const item = entry.path;
-      let path = sysPath.join(directory, item);
+      let path = sp.join(directory, item);
       current.add(item);
       if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path, item)) {
         return;
@@ -9510,7 +9695,7 @@ class NodeFsHandler {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path = sysPath.join(dir, sysPath.relative(dir, path));
+        path = sp.join(dir, sp.relative(dir, path));
         this._addToNodeFs(path, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
@@ -9536,12 +9721,12 @@ class NodeFsHandler {
     });
   }
   async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath2) {
-    const parentDir = this.fsw._getWatchedDir(sysPath.dirname(dir));
-    const tracked = parentDir.has(sysPath.basename(dir));
+    const parentDir = this.fsw._getWatchedDir(sp.dirname(dir));
+    const tracked = parentDir.has(sp.basename(dir));
     if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
       this.fsw._emit(EV.ADD_DIR, dir, stats);
     }
-    parentDir.add(sysPath.basename(dir));
+    parentDir.add(sp.basename(dir));
     this.fsw._getWatchedDir(dir);
     let throttler;
     let closer;
@@ -9582,7 +9767,7 @@ class NodeFsHandler {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sysPath.resolve(path);
+        const absPath = sp.resolve(path);
         const targetPath = follow ? await fsrealpath(path) : path;
         if (this.fsw.closed)
           return;
@@ -9596,14 +9781,14 @@ class NodeFsHandler {
         const targetPath = follow ? await fsrealpath(path) : path;
         if (this.fsw.closed)
           return;
-        const parent = sysPath.dirname(wh.watchPath);
+        const parent = sp.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
         closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== undefined) {
-          this.fsw._symlinkPaths.set(sysPath.resolve(path), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
@@ -9621,7 +9806,7 @@ class NodeFsHandler {
   }
 }
 
-// node_modules/chokidar/esm/index.js
+// node_modules/chokidar/index.js
 /*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */
 var SLASH = "/";
 var SLASH_SLASH = "//";
@@ -9629,7 +9814,7 @@ var ONE_DOT = ".";
 var TWO_DOTS = "..";
 var STRING_TYPE = "string";
 var BACK_SLASH_RE = /\\/g;
-var DOUBLE_SLASH_RE = /\/\//;
+var DOUBLE_SLASH_RE = /\/\//g;
 var DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
 var REPLACER_RE = /^\.[/\\]/;
 function arrify(item) {
@@ -9648,11 +9833,11 @@ function createPattern(matcher) {
       if (matcher.path === string)
         return true;
       if (matcher.recursive) {
-        const relative4 = sysPath2.relative(matcher.path, string);
-        if (!relative4) {
+        const relative5 = sp2.relative(matcher.path, string);
+        if (!relative5) {
           return false;
         }
-        return !relative4.startsWith("..") && !sysPath2.isAbsolute(relative4);
+        return !relative5.startsWith("..") && !sp2.isAbsolute(relative5);
       }
       return false;
     };
@@ -9662,14 +9847,12 @@ function createPattern(matcher) {
 function normalizePath(path) {
   if (typeof path !== "string")
     throw new Error("string expected");
-  path = sysPath2.normalize(path);
+  path = sp2.normalize(path);
   path = path.replace(/\\/g, "/");
   let prepend = false;
   if (path.startsWith("//"))
     prepend = true;
-  const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path.match(DOUBLE_SLASH_RE2))
-    path = path.replace(DOUBLE_SLASH_RE2, "/");
+  path = path.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
     path = "/" + path;
   return path;
@@ -9710,31 +9893,32 @@ var toUnix = (string) => {
   if (str.startsWith(SLASH_SLASH)) {
     prepend = true;
   }
-  while (str.match(DOUBLE_SLASH_RE)) {
-    str = str.replace(DOUBLE_SLASH_RE, SLASH);
-  }
+  str = str.replace(DOUBLE_SLASH_RE, SLASH);
   if (prepend) {
     str = SLASH + str;
   }
   return str;
 };
-var normalizePathToUnix = (path) => toUnix(sysPath2.normalize(toUnix(path)));
+var normalizePathToUnix = (path) => toUnix(sp2.normalize(toUnix(path)));
 var normalizeIgnored = (cwd = "") => (path) => {
   if (typeof path === "string") {
-    return normalizePathToUnix(sysPath2.isAbsolute(path) ? path : sysPath2.join(cwd, path));
+    return normalizePathToUnix(sp2.isAbsolute(path) ? path : sp2.join(cwd, path));
   } else {
     return path;
   }
 };
 var getAbsolutePath = (path, cwd) => {
-  if (sysPath2.isAbsolute(path)) {
+  if (sp2.isAbsolute(path)) {
     return path;
   }
-  return sysPath2.join(cwd, path);
+  return sp2.join(cwd, path);
 };
 var EMPTY_SET = Object.freeze(new Set);
 
 class DirEntry {
+  path;
+  _removeWatcher;
+  items;
   constructor(dir, removeWatcher) {
     this.path = dir;
     this._removeWatcher = removeWatcher;
@@ -9759,7 +9943,7 @@ class DirEntry {
       await readdir2(dir);
     } catch (err) {
       if (this._removeWatcher) {
-        this._removeWatcher(sysPath2.dirname(dir), sysPath2.basename(dir));
+        this._removeWatcher(sp2.dirname(dir), sp2.basename(dir));
       }
     }
   }
@@ -9787,12 +9971,19 @@ var STAT_METHOD_F = "stat";
 var STAT_METHOD_L = "lstat";
 
 class WatchHelper {
+  fsw;
+  path;
+  watchPath;
+  fullWatchPath;
+  dirParts;
+  followSymlinks;
+  statMethod;
   constructor(path, follow, fsw) {
     this.fsw = fsw;
     const watchPath = path;
     this.path = path = path.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
-    this.fullWatchPath = sysPath2.resolve(watchPath);
+    this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
     this.dirParts.forEach((parts) => {
       if (parts.length > 1)
@@ -9802,7 +9993,7 @@ class WatchHelper {
     this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
   }
   entryPath(entry) {
-    return sysPath2.join(this.watchPath, sysPath2.relative(this.watchPath, entry.fullPath));
+    return sp2.join(this.watchPath, sp2.relative(this.watchPath, entry.fullPath));
   }
   filterPath(entry) {
     const { stats } = entry;
@@ -9817,6 +10008,24 @@ class WatchHelper {
 }
 
 class FSWatcher extends EventEmitter {
+  closed;
+  options;
+  _closers;
+  _ignoredPaths;
+  _throttled;
+  _streams;
+  _symlinkPaths;
+  _watched;
+  _pendingWrites;
+  _pendingUnlinks;
+  _readyCount;
+  _emitReady;
+  _closePromise;
+  _userIgnored;
+  _readyEmitted;
+  _emitRaw;
+  _boundRemove;
+  _nodeFsHandler;
   constructor(_opts = {}) {
     super();
     this.closed = false;
@@ -9925,7 +10134,7 @@ class FSWatcher extends EventEmitter {
         return;
       results.forEach((item) => {
         if (item)
-          this.add(sysPath2.dirname(item), sysPath2.basename(_origAdd || item));
+          this.add(sp2.dirname(item), sp2.basename(_origAdd || item));
       });
     });
     return this;
@@ -9936,10 +10145,10 @@ class FSWatcher extends EventEmitter {
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
     paths.forEach((path) => {
-      if (!sysPath2.isAbsolute(path) && !this._closers.has(path)) {
+      if (!sp2.isAbsolute(path) && !this._closers.has(path)) {
         if (cwd)
-          path = sysPath2.join(cwd, path);
-        path = sysPath2.resolve(path);
+          path = sp2.join(cwd, path);
+        path = sp2.resolve(path);
       }
       this._closePath(path);
       this._addIgnoredPath(path);
@@ -9983,7 +10192,7 @@ class FSWatcher extends EventEmitter {
   getWatched() {
     const watchList = {};
     this._watched.forEach((entry, dir) => {
-      const key = this.options.cwd ? sysPath2.relative(this.options.cwd, dir) : dir;
+      const key = this.options.cwd ? sp2.relative(this.options.cwd, dir) : dir;
       const index = key || ONE_DOT;
       watchList[index] = entry.getChildren().sort();
     });
@@ -9999,9 +10208,9 @@ class FSWatcher extends EventEmitter {
       return;
     const opts = this.options;
     if (isWindows)
-      path = sysPath2.normalize(path);
+      path = sp2.normalize(path);
     if (opts.cwd)
-      path = sysPath2.relative(opts.cwd, path);
+      path = sp2.relative(opts.cwd, path);
     const args = [path];
     if (stats != null)
       args.push(stats);
@@ -10052,7 +10261,7 @@ class FSWatcher extends EventEmitter {
         return this;
     }
     if (opts.alwaysStat && stats === undefined && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path) : path;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path) : path;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -10108,8 +10317,8 @@ class FSWatcher extends EventEmitter {
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
     let fullPath = path;
-    if (this.options.cwd && !sysPath2.isAbsolute(path)) {
-      fullPath = sysPath2.join(this.options.cwd, path);
+    if (this.options.cwd && !sp2.isAbsolute(path)) {
+      fullPath = sp2.join(this.options.cwd, path);
     }
     const now = new Date;
     const writes = this._pendingWrites;
@@ -10166,7 +10375,7 @@ class FSWatcher extends EventEmitter {
     return new WatchHelper(path, this.options.followSymlinks, this);
   }
   _getWatchedDir(directory) {
-    const dir = sysPath2.resolve(directory);
+    const dir = sp2.resolve(directory);
     if (!this._watched.has(dir))
       this._watched.set(dir, new DirEntry(dir, this._boundRemove));
     return this._watched.get(dir);
@@ -10177,8 +10386,8 @@ class FSWatcher extends EventEmitter {
     return Boolean(Number(stats.mode) & 256);
   }
   _remove(directory, item, isDirectory) {
-    const path = sysPath2.join(directory, item);
-    const fullPath = sysPath2.resolve(path);
+    const path = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path);
     isDirectory = isDirectory != null ? isDirectory : this._watched.has(path) || this._watched.has(fullPath);
     if (!this._throttle("remove", path, 100))
       return;
@@ -10196,7 +10405,7 @@ class FSWatcher extends EventEmitter {
     }
     let relPath = path;
     if (this.options.cwd)
-      relPath = sysPath2.relative(this.options.cwd, path);
+      relPath = sp2.relative(this.options.cwd, path);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
@@ -10211,8 +10420,8 @@ class FSWatcher extends EventEmitter {
   }
   _closePath(path) {
     this._closeFile(path);
-    const dir = sysPath2.dirname(path);
-    this._getWatchedDir(dir).remove(sysPath2.basename(path));
+    const dir = sp2.dirname(path);
+    this._getWatchedDir(dir).remove(sp2.basename(path));
   }
   _closeFile(path) {
     const closers = this._closers.get(path);
@@ -10258,8 +10467,8 @@ function watch(paths, options = {}) {
 // src/commands/dev.ts
 function getEntryWatchPaths(root) {
   return [
-    join9(root, MANIFEST_FILE),
-    join9(root, "src", "actions.ts")
+    join10(root, MANIFEST_FILE),
+    join10(root, "src", "actions.ts")
   ];
 }
 async function dev() {
@@ -10298,26 +10507,59 @@ async function dev() {
     }
     console.log(source_default.blue("Actions changed -- entry regenerated"));
   });
-  const distDir = join9(root, "dist");
-  const bundleFile = join9(distDir, `space-${m.id}.iife.js`);
+  const distDir = join10(root, "dist");
+  const bundleFile = join10(distDir, `space-${m.id}.iife.js`);
+  const cssFile = join10(distDir, `space-${m.id}.css`);
   let lastChecksum = "";
-  const distWatcher = watch(bundleFile, { ignoreInitial: false });
-  distWatcher.on("all", () => {
-    if (!existsSync7(bundleFile))
+  const packageSpace = (force = false) => {
+    if (!existsSync8(bundleFile) || !existsSync8(cssFile))
       return;
     const bundleData = readFileSync5(bundleFile);
-    const checksum = createHash2("sha256").update(bundleData).digest("hex");
-    if (checksum === lastChecksum)
+    const checksum = createHash3("sha256").update(bundleData).digest("hex");
+    if (!force && checksum === lastChecksum)
       return;
     lastChecksum = checksum;
     const raw = readRaw(root);
     writeWithBuild(distDir, raw, {
       checksum,
       size: bundleData.length,
-      hostApiVersion: "0.5.0",
+      hostApiVersion: HOST_API_VERSION,
       builtAt: new Date().toISOString()
     });
-    console.log(source_default.green(`Built -> dist/ (${(bundleData.length / 1024).toFixed(1)} KB)`));
+    stageSpaceResources(root, distDir);
+    buildSpaceTools(root, distDir, m.id);
+    createSpaceBundle({
+      distDir,
+      spaceId: m.id,
+      appBundlePath: bundleFile,
+      cssPath: cssFile
+    });
+    console.log(source_default.green(`Built -> dist/${m.id}.space (${(bundleData.length / 1024).toFixed(1)} KB)`));
+  };
+  const distWatcher = watch([bundleFile, cssFile], { ignoreInitial: false });
+  distWatcher.on("all", () => {
+    try {
+      packageSpace();
+    } catch (err) {
+      console.error(source_default.red(err?.message || String(err)));
+    }
+  });
+  const resourceWatcher = watch([
+    join10(root, "tools.go"),
+    join10(root, "tools"),
+    join10(root, "lib"),
+    join10(root, "agent"),
+    join10(root, "scripts"),
+    join10(root, "references"),
+    join10(root, "assets"),
+    join10(root, "SKILL.md")
+  ], { ignoreInitial: true });
+  resourceWatcher.on("all", () => {
+    try {
+      packageSpace(true);
+    } catch (err) {
+      console.error(source_default.red(err?.message || String(err)));
+    }
   });
   console.log(source_default.green("Watching for changes... (Ctrl+C to stop)"));
   console.log(source_default.dim("Use the Preview button in Construct to open the Space Runner"));
@@ -10326,19 +10568,16 @@ async function dev() {
 
 // src/commands/run.ts
 init_source();
-import { existsSync as existsSync9, cpSync as cpSync2, mkdirSync as mkdirSync3, readdirSync as readdirSync4, chmodSync, lstatSync, rmSync } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync10, cpSync as cpSync2, mkdirSync as mkdirSync5, readdirSync as readdirSync4, chmodSync, lstatSync as lstatSync2, rmSync as rmSync3 } from "fs";
+import { join as join12 } from "path";
 init_appdir();
-function ensureBinExecutable(installDir) {
+function ensureExecutableResources(installDir) {
   if (process.platform === "win32")
     return;
-  const binRoot = join11(installDir, "bin");
-  if (!existsSync9(binRoot))
-    return;
   const walk = (dir) => {
     for (const name of readdirSync4(dir)) {
-      const path = join11(dir, name);
-      const st = lstatSync(path);
+      const path = join12(dir, name);
+      const st = lstatSync2(path);
       if (st.isSymbolicLink())
         continue;
       if (st.isDirectory()) {
@@ -10348,7 +10587,11 @@ function ensureBinExecutable(installDir) {
       }
     }
   };
-  walk(binRoot);
+  for (const dirname5 of ["tools", "lib"]) {
+    const root = join12(installDir, dirname5);
+    if (existsSync10(root))
+      walk(root);
+  }
 }
 function install() {
   const root = process.cwd();
@@ -10356,34 +10599,36 @@ function install() {
     console.error(source_default.red("No space.manifest.json found in current directory"));
     process.exit(1);
   }
-  const distDir = join11(root, "dist");
-  if (!existsSync9(distDir)) {
+  const distDir = join12(root, "dist");
+  if (!existsSync10(distDir)) {
     console.error(source_default.red("No dist/ directory found. Run 'construct build' first."));
     process.exit(1);
   }
   const m = read(root);
-  const agentDir = join11(root, "agent");
-  if (existsSync9(agentDir)) {
-    bundleAgentDir(agentDir, distDir);
+  const bundleDir = join12(distDir, `${m.id}.space`);
+  if (!existsSync10(bundleDir)) {
+    console.error(source_default.red(`No dist/${m.id}.space directory found. Run 'construct build' first.`));
+    process.exit(1);
   }
   const installDir = spaceDir(m.id);
-  rmSync(installDir, { recursive: true, force: true });
-  mkdirSync3(installDir, { recursive: true });
-  cpSync2(distDir, installDir, { recursive: true, verbatimSymlinks: true, force: true });
-  ensureBinExecutable(installDir);
+  rmSync3(join12(spacesDir(), m.id), { recursive: true, force: true });
+  rmSync3(installDir, { recursive: true, force: true });
+  mkdirSync5(installDir, { recursive: true });
+  cpSync2(bundleDir, installDir, { recursive: true, verbatimSymlinks: true, force: true });
+  ensureExecutableResources(installDir);
   console.log(source_default.green(`Installed ${m.name} -> ${installDir}`));
   console.log(source_default.dim("  Restart Construct to load the updated space."));
 }
 
 // src/commands/publish.ts
 init_source();
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync6, statSync as statSync5, unlinkSync as unlinkSync2 } from "fs";
-import { join as join14, basename as basename5 } from "path";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync6, statSync as statSync4, unlinkSync as unlinkSync2 } from "fs";
+import { join as join15, basename as basename5 } from "path";
 init_auth();
 
 // src/lib/pack.ts
-import { readdirSync as readdirSync6, statSync as statSync4, existsSync as existsSync11 } from "fs";
-import { join as join13 } from "path";
+import { readdirSync as readdirSync6, statSync as statSync3, existsSync as existsSync12 } from "fs";
+import { join as join14 } from "path";
 import { tmpdir } from "os";
 import { execFileSync as execFileSync2 } from "child_process";
 var allowedDirs = [
@@ -10406,7 +10651,9 @@ var allowedDirs = [
   "icons",
   "assets",
   "media",
-  "bin"
+  "tools",
+  "lib",
+  "go-tools"
 ];
 var allowedRootFiles = [
   "space.manifest.json",
@@ -10416,20 +10663,24 @@ var allowedRootFiles = [
   "vite.config.js",
   "space.config.ts",
   "types.ts",
-  "index.ts"
+  "index.ts",
+  "SKILL.md",
+  "tools.go",
+  "go.mod",
+  "go.sum"
 ];
 var allowedRootPatterns = [/.*\.config\.ts$/, /.*\.config\.js$/];
 var blockedExtensions = [".env", ".log", ".lock", ".lockb"];
 var MAX_SIZE = 50 * 1024 * 1024;
 async function packSource(root) {
-  const tarballPath = join13(tmpdir(), `space-source-${Date.now()}.tar.gz`);
+  const tarballPath = join14(tmpdir(), `space-source-${Date.now()}.tar.gz`);
   const entries = [];
   for (const name of allowedRootFiles) {
-    if (existsSync11(join13(root, name)))
+    if (existsSync12(join14(root, name)))
       entries.push(name);
   }
   for (const entry of readdirSync6(root)) {
-    if (statSync4(join13(root, entry)).isDirectory())
+    if (statSync3(join14(root, entry)).isDirectory())
       continue;
     if (allowedRootFiles.includes(entry))
       continue;
@@ -10439,10 +10690,10 @@ async function packSource(root) {
       entries.push(entry);
   }
   for (const dir of allowedDirs) {
-    if (existsSync11(join13(root, dir)))
+    if (existsSync12(join14(root, dir)))
       entries.push(dir);
   }
-  const validEntries = entries.filter((e) => existsSync11(join13(root, e)));
+  const validEntries = entries.filter((e) => existsSync12(join14(root, e)));
   if (validEntries.length === 0) {
     throw new Error("No files to pack");
   }
@@ -10450,13 +10701,15 @@ async function packSource(root) {
     "--exclude=node_modules",
     "--exclude=dist",
     "--exclude=.git",
+    "--exclude=go-tools/spaceprobe",
+    "--exclude=go-tools/spaceprobe.exe",
     "--exclude=*.env",
     "--exclude=*.log",
     "--exclude=*.lock",
     "--exclude=*.lockb"
   ];
   execFileSync2("tar", ["czf", tarballPath, ...excludes, ...validEntries], { cwd: root });
-  const size = statSync4(tarballPath).size;
+  const size = statSync3(tarballPath).size;
   if (size > MAX_SIZE) {
     throw new Error(`Source exceeds maximum size of ${MAX_SIZE / 1024 / 1024}MB`);
   }
@@ -10535,7 +10788,7 @@ function setVersionInFiles(root, oldVer, newVer) {
   const oldStr = `"version": "${oldVer}"`;
   const newStr = `"version": "${newVer}"`;
   for (const file of ["package.json", "space.manifest.json"]) {
-    const path = join14(root, file);
+    const path = join15(root, file);
     try {
       const data = readFileSync8(path, "utf-8");
       writeFileSync6(path, data.replace(oldStr, newStr));
@@ -10694,7 +10947,7 @@ async function publish(options) {
   let tarballPath;
   try {
     tarballPath = await packSource(root);
-    const size = statSync5(tarballPath).size;
+    const size = statSync4(tarballPath).size;
     spinner.succeed(`Source packed (${formatBytes(size)})`);
   } catch (err) {
     spinner.fail("Pack failed");
@@ -10762,8 +11015,8 @@ async function publish(options) {
 
 // src/commands/validate.ts
 init_source();
-import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync9 } from "fs";
+import { join as join16 } from "path";
 
 // src/lib/pagePaths.ts
 function pageComponentFromPath(path) {
@@ -10797,21 +11050,21 @@ function validate3() {
   let warnings = 0;
   for (const page of m.pages) {
     const component = page.component || pageComponentFromPath(page.path);
-    const fullPath = join15(root, "src", component);
-    if (!existsSync12(fullPath)) {
+    const fullPath = join16(root, "src", component);
+    if (!existsSync13(fullPath)) {
       console.log(source_default.yellow(`  \u26A0 Page component not found: src/${component}`));
       warnings++;
     }
   }
   if (m.agent) {
-    const agentPath = join15(root, m.agent);
-    if (!existsSync12(agentPath)) {
+    const agentPath = join16(root, m.agent);
+    if (!existsSync13(agentPath)) {
       console.log(source_default.yellow(`  \u26A0 Agent config not found: ${m.agent}`));
       warnings++;
     }
   }
-  const pkgPath = join15(root, "package.json");
-  if (existsSync12(pkgPath)) {
+  const pkgPath = join16(root, "package.json");
+  if (existsSync13(pkgPath)) {
     const pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
     if (pkg.version && pkg.version !== m.version) {
       console.log(source_default.yellow(`  \u26A0 Version mismatch: manifest=${m.version} package.json=${pkg.version}`));
@@ -10828,8 +11081,8 @@ function validate3() {
 // src/commands/check.ts
 init_source();
 import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync13, readFileSync as readFileSync10 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync10 } from "fs";
+import { join as join17 } from "path";
 function check() {
   const root = process.cwd();
   if (!exists(root)) {
@@ -10848,17 +11101,17 @@ function check() {
   let warnings = 0;
   for (const page of m.pages) {
     const component = page.component || pageComponentFromPath(page.path);
-    if (!existsSync13(join16(root, "src", component))) {
+    if (!existsSync14(join17(root, "src", component))) {
       console.log(source_default.yellow(`  \u26A0 Page not found: src/${component}`));
       warnings++;
     }
   }
-  if (m.agent && !existsSync13(join16(root, m.agent))) {
+  if (m.agent && !existsSync14(join17(root, m.agent))) {
     console.log(source_default.yellow(`  \u26A0 Agent config not found: ${m.agent}`));
     warnings++;
   }
-  const pkgPath = join16(root, "package.json");
-  if (existsSync13(pkgPath)) {
+  const pkgPath = join17(root, "package.json");
+  if (existsSync14(pkgPath)) {
     const pkg = JSON.parse(readFileSync10(pkgPath, "utf-8"));
     if (pkg.version && pkg.version !== m.version) {
       console.log(source_default.yellow(`  \u26A0 Version mismatch: manifest=${m.version} package.json=${pkg.version}`));
@@ -10891,8 +11144,8 @@ function check() {
 
 // src/commands/clean.ts
 init_source();
-import { rmSync as rmSync2, existsSync as existsSync14 } from "fs";
-import { join as join17 } from "path";
+import { rmSync as rmSync4, existsSync as existsSync15 } from "fs";
+import { join as join18 } from "path";
 function clean(options) {
   const root = process.cwd();
   const dirs = ["dist", ".vite"];
@@ -10901,17 +11154,17 @@ function clean(options) {
   }
   const lockfiles = ["bun.lockb", "package-lock.json", "yarn.lock", "pnpm-lock.yaml"];
   for (const dir of dirs) {
-    const path = join17(root, dir);
-    if (existsSync14(path)) {
-      rmSync2(path, { recursive: true });
+    const path = join18(root, dir);
+    if (existsSync15(path)) {
+      rmSync4(path, { recursive: true });
       console.log(source_default.dim(`  Removed ${dir}/`));
     }
   }
   if (options?.all) {
     for (const file of lockfiles) {
-      const path = join17(root, file);
-      if (existsSync14(path)) {
-        rmSync2(path);
+      const path = join18(root, file);
+      if (existsSync15(path)) {
+        rmSync4(path);
         console.log(source_default.dim(`  Removed ${file}`));
       }
     }
@@ -11071,8 +11324,8 @@ function update() {
 
 // src/commands/graph/init.ts
 init_source();
-import { existsSync as existsSync15, readFileSync as readFileSync11, writeFileSync as writeFileSync7, mkdirSync as mkdirSync5 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync11, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7 } from "fs";
+import { join as join19 } from "path";
 import { execSync as execSync4 } from "child_process";
 function graphInit() {
   const root = process.cwd();
@@ -11082,10 +11335,10 @@ function graphInit() {
     process.exit(1);
   }
   const m = read(root);
-  const modelsDir = join18(root, "src", "models");
-  mkdirSync5(modelsDir, { recursive: true });
-  const indexPath = join18(modelsDir, "index.ts");
-  if (!existsSync15(indexPath)) {
+  const modelsDir = join19(root, "src", "models");
+  mkdirSync7(modelsDir, { recursive: true });
+  const indexPath = join19(modelsDir, "index.ts");
+  if (!existsSync16(indexPath)) {
     writeFileSync7(indexPath, `// Data models for ${m.name}
 // Generated by construct graph init
 
@@ -11093,7 +11346,7 @@ function graphInit() {
 // export { User } from './User'
 `);
   }
-  const pkgPath = join18(root, "package.json");
+  const pkgPath = join19(root, "package.json");
   const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
   if (!pkg.dependencies)
     pkg.dependencies = {};
@@ -11125,8 +11378,8 @@ function graphInit() {
 
 // src/commands/graph/generate.ts
 init_source();
-import { existsSync as existsSync16, readFileSync as readFileSync12, writeFileSync as writeFileSync8, mkdirSync as mkdirSync6 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync12, writeFileSync as writeFileSync8, mkdirSync as mkdirSync8 } from "fs";
+import { join as join20 } from "path";
 var FIELD_TYPES = {
   string: "field.string()",
   int: "field.int()",
@@ -11278,10 +11531,10 @@ function generate2(modelName, fieldSpecs, options) {
   lines.push("");
   const content = lines.join(`
 `);
-  const modelsDir = join19(root, "src", "models");
-  mkdirSync6(modelsDir, { recursive: true });
-  const filePath = join19(modelsDir, `${name}.ts`);
-  if (existsSync16(filePath)) {
+  const modelsDir = join20(root, "src", "models");
+  mkdirSync8(modelsDir, { recursive: true });
+  const filePath = join20(modelsDir, `${name}.ts`);
+  if (existsSync17(filePath)) {
     console.log(source_default.yellow(`  Model file already exists: src/models/${name}.ts`));
     console.log(source_default.dim("  Overwriting..."));
   }
@@ -11298,9 +11551,9 @@ function generate2(modelName, fieldSpecs, options) {
   console.log();
 }
 function updateBarrel(modelsDir, modelName) {
-  const indexPath = join19(modelsDir, "index.ts");
+  const indexPath = join20(modelsDir, "index.ts");
   const exportLine = `export { ${modelName} } from './${modelName}'`;
-  if (existsSync16(indexPath)) {
+  if (existsSync17(indexPath)) {
     const content = readFileSync12(indexPath, "utf-8");
     if (content.includes(exportLine))
       return;
@@ -11316,8 +11569,8 @@ function updateBarrel(modelsDir, modelName) {
 
 // src/commands/graph/push.ts
 init_source();
-import { existsSync as existsSync17, readdirSync as readdirSync7, readFileSync as readFileSync13 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync18, readdirSync as readdirSync7, readFileSync as readFileSync13 } from "fs";
+import { join as join21 } from "path";
 init_auth();
 async function graphPush() {
   const root = process.cwd();
@@ -11326,8 +11579,8 @@ async function graphPush() {
     process.exit(1);
   }
   const m = read(root);
-  const modelsDir = join20(root, "src", "models");
-  if (!existsSync17(modelsDir)) {
+  const modelsDir = join21(root, "src", "models");
+  if (!existsSync18(modelsDir)) {
     console.error(source_default.red("No src/models/ directory found. Run 'construct graph init' first."));
     process.exit(1);
   }
@@ -11340,7 +11593,7 @@ async function graphPush() {
   console.log(source_default.blue(`Pushing ${modelFiles.length} model(s) for space: ${m.id}`));
   const models = [];
   for (const file of modelFiles) {
-    const content = readFileSync13(join20(modelsDir, file), "utf-8");
+    const content = readFileSync13(join21(modelsDir, file), "utf-8");
     const model = parseModelFile(content);
     if (model)
       models.push(model);
@@ -11523,8 +11776,8 @@ function parseModelFile(content) {
 
 // src/commands/graph/migrate.ts
 init_source();
-import { existsSync as existsSync18, readdirSync as readdirSync8, readFileSync as readFileSync14 } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync19, readdirSync as readdirSync8, readFileSync as readFileSync14 } from "fs";
+import { join as join22 } from "path";
 init_auth();
 async function graphMigrate(options) {
   const root = process.cwd();
@@ -11533,8 +11786,8 @@ async function graphMigrate(options) {
     process.exit(1);
   }
   const m = read(root);
-  const modelsDir = join21(root, "src", "models");
-  if (!existsSync18(modelsDir)) {
+  const modelsDir = join22(root, "src", "models");
+  if (!existsSync19(modelsDir)) {
     console.error(source_default.red("No src/models/ directory. Run 'construct graph init' first."));
     process.exit(1);
   }
@@ -11564,7 +11817,7 @@ async function graphMigrate(options) {
   const modelFiles = readdirSync8(modelsDir).filter((f) => f.endsWith(".ts") && f !== "index.ts");
   const localModels = [];
   for (const file of modelFiles) {
-    const content = readFileSync14(join21(modelsDir, file), "utf-8");
+    const content = readFileSync14(join22(modelsDir, file), "utf-8");
     const model = parseModelFields(content);
     if (model)
       localModels.push(model);
@@ -11700,7 +11953,7 @@ function graphFork(newSpaceID) {
 // package.json
 var package_default = {
   name: "@construct-space/cli",
-  version: "1.9.4",
+  version: "1.9.6",
   description: "Construct CLI \u2014 scaffold, build, develop, and publish spaces",
   type: "module",
   bin: {
@@ -11719,7 +11972,9 @@ var package_default = {
     build: "bun build src/index.ts --outdir dist --target bun --format esm && cp -r templates dist/",
     dev: "bun run src/index.ts",
     test: "bun test",
-    typecheck: "tsc --noEmit"
+    typecheck: "tsc --noEmit",
+    lint: "eslint src",
+    "lint:fix": "eslint src --fix"
   },
   dependencies: {
     commander: "^14.0.3",
@@ -11730,7 +11985,10 @@ var package_default = {
   },
   devDependencies: {
     "@types/bun": "latest",
-    typescript: "^6.0.2"
+    typescript: "^6.0.2",
+    eslint: "^10.4.0",
+    "@eslint/js": "^10.0.1",
+    "typescript-eslint": "^8.59.4"
   },
   keywords: [
     "construct",