@tomvandig/mosaic 0.1.0 → 0.2.0

package/README.md

@@ -5,6 +5,9 @@ incremental collaboration on geometric, structured data.
 
 ```bash
 npx @tomvandig/mosaic help
+
+# convert a glTF model, straight from a URL
+npx @tomvandig/mosaic pack https://tomvandig.github.io/mosaic/dist/docs/models/DamagedHelmet.glb
 ```
 
 Or install it, and the command is `mosaic`:
@@ -20,12 +23,9 @@ Needs Node.js 24 or later.
 
 | Command | |
 | --- | --- |
-| `mosaic pack <input.json> [output.tsr]` | Pack a Mosaic source document into a `.tsr` archive |
-| `mosaic gltf <input.gltf\|.glb> [output.mosaic.json] [--stable-ids]` | Convert glTF into a source document |
-| `mosaic gltf-pack <input.gltf\|.glb> [output.tsr] [--stable-ids]` | Convert glTF straight into an archive |
-| `mosaic ifc <input.ifc> [output.mosaic.json]` | Convert an IFC model into a source document |
-| `mosaic ifc-pack <input.ifc> [output.tsr]` | Convert an IFC model straight into an archive |
-| `mosaic svg-pack <input.svg> [output.tsr]` | Pack an SVG into an archive of one node |
+| `mosaic pack <input> [output.tsr] [flags]` | Pack into a `.tsr` archive, by extension: a source document (`.json`), glTF (`.gltf`, `.glb`, or a URL), IFC (`.ifc`) or SVG (`.svg`) |
+| `mosaic gltf <input.gltf\|.glb\|url> [output.mosaic.json] [--stable-ids]` | Convert glTF into an editable source document |
+| `mosaic ifc <input.ifc> [output.mosaic.json] [--center] [--no-geometry] [--seed=<text>]` | Convert an IFC model into an editable source document |
 | `mosaic compose <input.tsr\|.duckdb> [output.glb]` | Compose an archive and its imports into a `.glb` |
 | `mosaic serve <database.duckdb> [--port <n>] [--host <name>]` | Serve the Mosaic API, and a viewer, over a database |
 | `mosaic codegen <input_dir> <output_dir> <ts\|cs>` | Generate typed classes from component schemas |

package/dist/mosaic.cjs

@@ -16242,14 +16242,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs9 = this.flowScalar(this.type);
+              const fs10 = this.flowScalar(this.type);
               if (atNextItem || it.value) {
-                map.items.push({ start, key: fs9, sep: [] });
+                map.items.push({ start, key: fs10, sep: [] });
                 this.onKeyLine = true;
               } else if (it.sep) {
-                this.stack.push(fs9);
+                this.stack.push(fs10);
               } else {
-                Object.assign(it, { key: fs9, sep: [] });
+                Object.assign(it, { key: fs10, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -16377,13 +16377,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs9 = this.flowScalar(this.type);
+              const fs10 = this.flowScalar(this.type);
               if (!it || it.value)
-                fc.items.push({ start: [], key: fs9, sep: [] });
+                fc.items.push({ start: [], key: fs10, sep: [] });
               else if (it.sep)
-                this.stack.push(fs9);
+                this.stack.push(fs10);
               else
-                Object.assign(it, { key: fs9, sep: [] });
+                Object.assign(it, { key: fs10, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -66259,11 +66259,11 @@ var require_dist4 = __commonJS({
 // node_modules/is-url/index.js
 var require_is_url = __commonJS({
   "node_modules/is-url/index.js"(exports2, module2) {
-    module2.exports = isUrl;
+    module2.exports = isUrl2;
     var protocolAndDomainRE = /^(?:\w+:)?\/\/(\S+)$/;
     var localhostDomainRE = /^localhost[\:?\d]*(?:[^\:?\d]\S*)?$/;
     var nonLocalhostDomainRE = /^[^\s\.]+\.\S{2,}$/;
-    function isUrl(string) {
+    function isUrl2(string) {
       if (typeof string !== "string") {
         return false;
       }
@@ -69046,12 +69046,12 @@ var require_lib2 = __commonJS({
       const dest = new URL$1(destination).protocol;
       return orig === dest;
     };
-    function fetch(url, opts) {
-      if (!fetch.Promise) {
+    function fetch2(url, opts) {
+      if (!fetch2.Promise) {
         throw new Error("native promise missing, set fetch.Promise to your favorite alternative");
       }
-      Body.Promise = fetch.Promise;
-      return new fetch.Promise(function(resolve, reject) {
+      Body.Promise = fetch2.Promise;
+      return new fetch2.Promise(function(resolve, reject) {
         const request = new Request(url, opts);
         const options = getNodeRequestOptions(request);
         const send2 = (options.protocol === "https:" ? https : http2).request;
@@ -69122,7 +69122,7 @@ var require_lib2 = __commonJS({
         req.on("response", function(res) {
           clearTimeout(reqTimeout);
           const headers = createHeadersLenient(res.headers);
-          if (fetch.isRedirect(res.statusCode)) {
+          if (fetch2.isRedirect(res.statusCode)) {
             const location2 = headers.get("Location");
             let locationURL = null;
             try {
@@ -69184,7 +69184,7 @@ var require_lib2 = __commonJS({
                   requestOpts.body = void 0;
                   requestOpts.headers.delete("content-length");
                 }
-                resolve(fetch(new Request(locationURL, requestOpts)));
+                resolve(fetch2(new Request(locationURL, requestOpts)));
                 finalize();
                 return;
             }
@@ -69276,11 +69276,11 @@ var require_lib2 = __commonJS({
         stream.end();
       }
     }
-    fetch.isRedirect = function(code) {
+    fetch2.isRedirect = function(code) {
       return code === 301 || code === 302 || code === 303 || code === 307 || code === 308;
     };
-    fetch.Promise = global.Promise;
-    module2.exports = exports2 = fetch;
+    fetch2.Promise = global.Promise;
+    module2.exports = exports2 = fetch2;
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.default = exports2;
     exports2.Headers = Headers;
@@ -69296,19 +69296,19 @@ var require_node_ponyfill = __commonJS({
   "node_modules/cross-fetch/dist/node-ponyfill.js"(exports2, module2) {
     var nodeFetch = require_lib2();
     var realFetch = nodeFetch.default || nodeFetch;
-    var fetch = function(url, options) {
+    var fetch2 = function(url, options) {
       if (/^\/\//.test(url)) {
         url = "https:" + url;
       }
       return realFetch.call(this, url, options);
     };
-    fetch.ponyfill = true;
-    module2.exports = exports2 = fetch;
-    exports2.fetch = fetch;
+    fetch2.ponyfill = true;
+    module2.exports = exports2 = fetch2;
+    exports2.fetch = fetch2;
     exports2.Headers = nodeFetch.Headers;
     exports2.Request = nodeFetch.Request;
     exports2.Response = nodeFetch.Response;
-    exports2.default = fetch;
+    exports2.default = fetch2;
   }
 });
 
@@ -69319,11 +69319,11 @@ var require_fetch = __commonJS({
     var _a;
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.fetch = void 0;
-    var fetch;
+    var fetch2;
     try {
-      exports2.fetch = fetch = (_a = global.fetch) !== null && _a !== void 0 ? _a : require_node_ponyfill().default;
+      exports2.fetch = fetch2 = (_a = global.fetch) !== null && _a !== void 0 ? _a : require_node_ponyfill().default;
     } catch (_b) {
-      exports2.fetch = fetch = require_node_ponyfill().default;
+      exports2.fetch = fetch2 = require_node_ponyfill().default;
     }
   }
 });
@@ -69446,7 +69446,7 @@ var require_NodeIO = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.readableFromFileOrURL = readableFromFileOrURL;
     exports2.readFromFileOrURL = readFromFileOrURL;
-    var fs9 = __importStar(require("fs"));
+    var fs10 = __importStar(require("fs"));
     var path17 = __importStar(require("path"));
     var ts_necessities_1 = require_dist3();
     var browser_or_node_1 = require_dist4();
@@ -69496,10 +69496,10 @@ var require_NodeIO = __commonJS({
       return body;
     }
     function resolveSymbolicLink(filePath) {
-      if (!fs9.lstatSync(filePath).isSymbolicLink()) {
+      if (!fs10.lstatSync(filePath).isSymbolicLink()) {
         return filePath;
       }
-      const linkPath = fs9.readlinkSync(filePath);
+      const linkPath = fs10.readlinkSync(filePath);
       if (path17.isAbsolute(linkPath)) {
         return linkPath;
       }
@@ -69519,8 +69519,8 @@ var require_NodeIO = __commonJS({
               return process.stdin;
             }
             const filePath = resolveSymbolicLink(fileOrURL);
-            if (fs9.existsSync(filePath)) {
-              return fs9.createReadStream(filePath, "utf8");
+            if (fs10.existsSync(filePath)) {
+              return fs10.createReadStream(filePath, "utf8");
             }
           }
         } catch (e) {
@@ -81589,8 +81589,8 @@ var init_ComposeFs = __esm({
 var require_duckdb_binding = __commonJS({
   "src/duckdb-binding.cjs"(exports2, module2) {
     "use strict";
-    var fs9 = require("node:fs");
-    var os = require("node:os");
+    var fs10 = require("node:fs");
+    var os2 = require("node:os");
     var path17 = require("node:path");
     var zlib2 = require("node:zlib");
     var { createRequire: createRequire3 } = require("node:module");
@@ -81599,36 +81599,36 @@ var require_duckdb_binding = __commonJS({
     function cacheRoot() {
       const asked = process.env.MOSAIC_DUCKDB_CACHE;
       if (asked) return asked;
-      const home = os.homedir();
+      const home = os2.homedir();
       if (process.platform === "win32") {
-        return process.env.LOCALAPPDATA || (home ? path17.join(home, "AppData", "Local") : os.tmpdir());
+        return process.env.LOCALAPPDATA || (home ? path17.join(home, "AppData", "Local") : os2.tmpdir());
       }
       if (process.platform === "darwin") {
-        return home ? path17.join(home, "Library", "Caches") : os.tmpdir();
+        return home ? path17.join(home, "Library", "Caches") : os2.tmpdir();
       }
-      return process.env.XDG_CACHE_HOME || (home ? path17.join(home, ".cache") : os.tmpdir());
+      return process.env.XDG_CACHE_HOME || (home ? path17.join(home, ".cache") : os2.tmpdir());
     }
     function unpack(sea) {
       const into = path17.join(cacheRoot(), "mosaic", "duckdb-" + VERSION2);
       const keys = sea.getAssetKeys().filter((key) => key.startsWith(PREFIX));
       if (keys.length === 0) return void 0;
-      fs9.mkdirSync(into, { recursive: true });
+      fs10.mkdirSync(into, { recursive: true });
       for (const key of keys) {
         const name = path17.basename(key).replace(/\.br$/, "");
         const target = path17.join(into, name);
         try {
-          if (fs9.statSync(target).size > 0) continue;
+          if (fs10.statSync(target).size > 0) continue;
         } catch {
         }
         const packed = Buffer.from(sea.getRawAsset(key));
         const bytes = key.endsWith(".br") ? zlib2.brotliDecompressSync(packed) : packed;
         const partial = target + "." + process.pid + ".part";
-        fs9.writeFileSync(partial, bytes);
+        fs10.writeFileSync(partial, bytes);
         try {
-          fs9.renameSync(partial, target);
+          fs10.renameSync(partial, target);
         } catch (error) {
-          fs9.rmSync(partial, { force: true });
-          if (!fs9.existsSync(target)) throw error;
+          fs10.rmSync(partial, { force: true });
+          if (!fs10.existsSync(target)) throw error;
         }
       }
       return into;
@@ -92030,11 +92030,11 @@ async function exportArchivesToDatabase(archivePaths, databasePath) {
   for (const archivePath of archivePaths) inserted.push(await database.insertArchive(archivePath));
   return { database, inserted };
 }
-var import_node_fs7, import_node_path13, FIXED_SCHEMA, BATCH_ROWS, FROM_JSON_ROWS, MosaicDatabase;
+var import_node_fs8, import_node_path13, FIXED_SCHEMA, BATCH_ROWS, FROM_JSON_ROWS, MosaicDatabase;
 var init_Export = __esm({
   "../ts/src/duckdb/Export.ts"() {
     "use strict";
-    import_node_fs7 = __toESM(require("node:fs"), 1);
+    import_node_fs8 = __toESM(require("node:fs"), 1);
     import_node_path13 = __toESM(require("node:path"), 1);
     init_runtime();
     init_MosaicFile();
@@ -92110,7 +92110,7 @@ var init_Export = __esm({
        * so the same call makes a new database or adds to an existing one.
        */
       static async open(databasePath) {
-        if (databasePath !== ":memory:") import_node_fs7.default.mkdirSync(import_node_path13.default.dirname(import_node_path13.default.resolve(databasePath)), { recursive: true });
+        if (databasePath !== ":memory:") import_node_fs8.default.mkdirSync(import_node_path13.default.dirname(import_node_path13.default.resolve(databasePath)), { recursive: true });
         const { DuckDBInstance } = await duckdb();
         const instance = await DuckDBInstance.create(databasePath);
         const connection = await instance.connect();
@@ -92156,9 +92156,9 @@ var init_Export = __esm({
       }
       /** Reads an archive and appends it. Nothing already in the database is touched. */
       async insertArchive(archivePath, options = {}) {
-        if (!import_node_fs7.default.existsSync(archivePath)) throw new Error(`File ${archivePath} does not exist`);
+        if (!import_node_fs8.default.existsSync(archivePath)) throw new Error(`File ${archivePath} does not exist`);
         const source = import_node_path13.default.resolve(archivePath);
-        const file = await LoadMosaicFile(import_node_fs7.default.readFileSync(source));
+        const file = await LoadMosaicFile(import_node_fs8.default.readFileSync(source));
         return await this.insertFile(file, options.fileId ?? import_node_path13.default.basename(source).split(".")[0], source);
       }
       /** Appends an already-loaded file. */
@@ -92789,7 +92789,7 @@ function glbOutputPathForDatabase(databasePath) {
   return import_node_path14.default.join(import_node_path14.default.dirname(databasePath), `${stem}${GLB_EXTENSION}`);
 }
 async function composeDatabaseToGlb(databasePath, outputPath, options = {}) {
-  if (!import_node_fs8.default.existsSync(databasePath)) throw new Error(`File ${databasePath} does not exist`);
+  if (!import_node_fs9.default.existsSync(databasePath)) throw new Error(`File ${databasePath} does not exist`);
   const database = await MosaicDatabase.open(databasePath);
   try {
     const wanted = options.files;
@@ -92798,8 +92798,8 @@ async function composeDatabaseToGlb(databasePath, outputPath, options = {}) {
     const composed = mosaicToGltf(file);
     const target = import_node_path14.default.resolve(outputPath ?? glbOutputPathForDatabase(import_node_path14.default.resolve(databasePath)));
     const bytes = writeGlb(composed.document, composed.binary);
-    import_node_fs8.default.mkdirSync(import_node_path14.default.dirname(target), { recursive: true });
-    import_node_fs8.default.writeFileSync(target, bytes);
+    import_node_fs9.default.mkdirSync(import_node_path14.default.dirname(target), { recursive: true });
+    import_node_fs9.default.writeFileSync(target, bytes);
     return {
       outputPath: target,
       byteLength: bytes.byteLength,
@@ -92813,11 +92813,11 @@ async function composeDatabaseToGlb(databasePath, outputPath, options = {}) {
     await database.close();
   }
 }
-var import_node_fs8, import_node_path14;
+var import_node_fs9, import_node_path14;
 var init_Compose = __esm({
   "../ts/src/duckdb/Compose.ts"() {
     "use strict";
-    import_node_fs8 = __toESM(require("node:fs"), 1);
+    import_node_fs9 = __toESM(require("node:fs"), 1);
     import_node_path14 = __toESM(require("node:path"), 1);
     init_MosaicToGltf();
     init_GlbWriter();
@@ -95354,7 +95354,7 @@ async function runCodegen(argv) {
 }
 
 // src/commands/pack.ts
-var import_node_path6 = __toESM(require("node:path"), 1);
+var import_node_path11 = __toESM(require("node:path"), 1);
 
 // ../ts/src/index.ts
 init_MosaicFile();
@@ -95989,7 +95989,7 @@ function svgToMosaic(svg, options = {}) {
           dataVersion: options.provenance?.dataVersion ?? "1.0.0",
           author: options.provenance?.author ?? "",
           timestamp: options.provenance?.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
-          application: options.provenance?.application ?? "mosaic svg-pack"
+          application: options.provenance?.application ?? "mosaic pack"
         },
         nodes: [{
           id: nodeId,
@@ -96043,27 +96043,49 @@ init_ComposeFs();
 // ../ts/src/index.ts
 init_MosaicIndexFile();
 
-// src/commands/pack.ts
-var PACK_USAGE = `mosaic pack <input.json> [output${MOSAIC_ARCHIVE_EXTENSION}]`;
-async function runPack(argv) {
-  const [input_path, output_path] = argv;
-  if (input_path === void 0) {
-    throw new Error(`Usage: ${PACK_USAGE}`);
-  }
-  const result = await packMosaicSourceFile(input_path, output_path);
-  console.log(`Packed: ${import_node_path6.default.resolve(input_path)} -> ${result.outputPath}`);
-  console.log();
-  console.log(`Component tables (${result.componentCount} rows):`);
-  result.tables.forEach((table) => console.log(` - ${table}`));
-  console.log();
-  console.log(`Wrote ${result.byteLength} bytes.`);
-}
-
 // src/commands/gltf.ts
-var import_node_path7 = __toESM(require("node:path"), 1);
+var import_node_fs6 = __toESM(require("node:fs"), 1);
+var import_node_os = __toESM(require("node:os"), 1);
+var import_node_path6 = __toESM(require("node:path"), 1);
 var STABLE_IDS = "--stable-ids";
-var GLTF_USAGE = `mosaic gltf <input.gltf|input.glb> [output${MOSAIC_SOURCE_EXTENSION}] [${STABLE_IDS}]`;
-var GLTF_PACK_USAGE = `mosaic gltf-pack <input.gltf|input.glb> [output.tsr] [${STABLE_IDS}]`;
+var GLTF_USAGE = `mosaic gltf <input.gltf|input.glb|url> [output${MOSAIC_SOURCE_EXTENSION}] [${STABLE_IDS}]`;
+var GLTF_PACK_USAGE = `mosaic pack <input.gltf|input.glb|url> [output.tsr] [${STABLE_IDS}]`;
+var isUrl = (input) => /^https?:\/\//i.test(input);
+var isRelative = (uri) => typeof uri === "string" && uri.length > 0 && !/^[a-z][a-z0-9+.-]*:/i.test(uri);
+async function download(url, target) {
+  const response = await fetch(url);
+  if (!response.ok) throw new Error(`Could not download ${url}: ${response.status} ${response.statusText}`);
+  import_node_fs6.default.mkdirSync(import_node_path6.default.dirname(target), { recursive: true });
+  import_node_fs6.default.writeFileSync(target, new Uint8Array(await response.arrayBuffer()));
+}
+async function localInput(input) {
+  if (!isUrl(input)) return { file: input, done() {
+  } };
+  const url = new URL(input);
+  const name = decodeURIComponent(import_node_path6.default.posix.basename(url.pathname)) || "model.glb";
+  const folder = import_node_fs6.default.mkdtempSync(import_node_path6.default.join(import_node_os.default.tmpdir(), "mosaic-gltf-"));
+  const file = import_node_path6.default.join(folder, name);
+  console.log(`Downloading ${url}`);
+  await download(url, file);
+  if (name.toLowerCase().endsWith(".gltf")) {
+    const document = JSON.parse(import_node_fs6.default.readFileSync(file, "utf-8"));
+    const beside = [...document.buffers ?? [], ...document.images ?? []].map((entry) => entry.uri).filter(isRelative);
+    for (const uri of new Set(beside)) {
+      const target = import_node_path6.default.resolve(folder, decodeURIComponent(uri));
+      if (!target.startsWith(folder + import_node_path6.default.sep)) throw new Error(`${name} refers to ${uri}, outside its own folder`);
+      await download(new URL(uri, url), target);
+    }
+  }
+  return {
+    file,
+    defaultDirectory: process.cwd(),
+    done: () => import_node_fs6.default.rmSync(folder, { recursive: true, force: true })
+  };
+}
+function defaultOutput(file, directory, extension) {
+  if (directory === void 0) return void 0;
+  return import_node_path6.default.join(directory, import_node_path6.default.basename(file).split(".")[0] + extension);
+}
 function readArgs(argv) {
   return {
     positional: argv.filter((arg) => !arg.startsWith("--")),
@@ -96071,7 +96093,7 @@ function readArgs(argv) {
   };
 }
 function report(inputPath, result, stable = false) {
-  console.log(`Converted: ${import_node_path7.default.resolve(inputPath)} -> ${result.outputPath}`);
+  console.log(`Converted: ${isUrl(inputPath) ? inputPath : import_node_path6.default.resolve(inputPath)} -> ${result.outputPath}`);
   console.log();
   console.log(`Nodes: ${result.nodeCount}`);
   if (stable) console.log(`Ids: derived from the file name, so this conversion repeats exactly`);
@@ -96091,17 +96113,29 @@ async function runGltf(argv) {
   const { positional, stableIds: stableIds2 } = readArgs(argv);
   const [input_path, output_path] = positional;
   if (input_path === void 0) throw new Error(`Usage: ${GLTF_USAGE}`);
-  report(input_path, convertGltfToSourceFile(input_path, output_path, { stableIds: stableIds2 }), stableIds2);
+  const input = await localInput(input_path);
+  try {
+    const output = output_path ?? defaultOutput(input.file, input.defaultDirectory, MOSAIC_SOURCE_EXTENSION);
+    report(input_path, convertGltfToSourceFile(input.file, output, { stableIds: stableIds2 }), stableIds2);
+  } finally {
+    input.done();
+  }
 }
 async function runGltfPack(argv) {
   const { positional, stableIds: stableIds2 } = readArgs(argv);
   const [input_path, output_path] = positional;
   if (input_path === void 0) throw new Error(`Usage: ${GLTF_PACK_USAGE}`);
-  report(input_path, await convertGltfToArchiveFile(input_path, output_path, { stableIds: stableIds2 }), stableIds2);
+  const input = await localInput(input_path);
+  try {
+    const output = output_path ?? defaultOutput(input.file, input.defaultDirectory, ".tsr");
+    report(input_path, await convertGltfToArchiveFile(input.file, output, { stableIds: stableIds2 }), stableIds2);
+  } finally {
+    input.done();
+  }
 }
 
 // src/commands/ifc.ts
-var import_node_path10 = __toESM(require("node:path"), 1);
+var import_node_path9 = __toESM(require("node:path"), 1);
 
 // ../ifc4/src/schemas/entity.schema.json
 var entity_schema_default = {
@@ -97092,12 +97126,12 @@ function ifc4ToMosaic(api, modelID, options = {}) {
 }
 
 // ../ifc4/src/Ifc4ConvertFs.ts
-var import_node_fs6 = __toESM(require("node:fs"), 1);
-var import_node_path9 = __toESM(require("node:path"), 1);
+var import_node_fs7 = __toESM(require("node:fs"), 1);
+var import_node_path8 = __toESM(require("node:path"), 1);
 
 // ../ifc4/src/runtime.ts
 var import_node_module = require("node:module");
-var import_node_path8 = __toESM(require("node:path"), 1);
+var import_node_path7 = __toESM(require("node:path"), 1);
 var loaded;
 async function webIfc() {
   if (loaded) return loaded;
@@ -97111,13 +97145,13 @@ async function webIfc() {
   const roots = [
     process.env.MOSAIC_WEBIFC,
     // Beside the bundle itself, which is where an npm install of the CLI puts it.
-    process.argv[1] === void 0 ? void 0 : import_node_path8.default.dirname(process.argv[1]),
+    process.argv[1] === void 0 ? void 0 : import_node_path7.default.dirname(process.argv[1]),
     process.cwd(),
-    import_node_path8.default.dirname(process.execPath)
-  ].filter((root) => typeof root === "string" && root.length > 0).map((root) => import_node_path8.default.join(root, "index.js"));
+    import_node_path7.default.dirname(process.execPath)
+  ].filter((root) => typeof root === "string" && root.length > 0).map((root) => import_node_path7.default.join(root, "index.js"));
   for (const root of roots) {
     try {
-      const require2 = (0, import_node_module.createRequire)(import_node_path8.default.resolve(root));
+      const require2 = (0, import_node_module.createRequire)(import_node_path7.default.resolve(root));
       loaded = require2("web-ifc");
       return loaded;
     } catch (error) {
@@ -97138,15 +97172,15 @@ function message(error) {
 // ../ifc4/src/Ifc4ConvertFs.ts
 var MOSAIC_SOURCE_EXTENSION2 = ".mosaic.json";
 function stemOf(inputPath) {
-  const base = import_node_path9.default.basename(inputPath);
+  const base = import_node_path8.default.basename(inputPath);
   const dot = base.lastIndexOf(".");
   return dot > 0 ? base.slice(0, dot) : base;
 }
 function sourceOutputPath2(inputPath) {
-  return import_node_path9.default.join(import_node_path9.default.dirname(inputPath), `${stemOf(inputPath)}${MOSAIC_SOURCE_EXTENSION2}`);
+  return import_node_path8.default.join(import_node_path8.default.dirname(inputPath), `${stemOf(inputPath)}${MOSAIC_SOURCE_EXTENSION2}`);
 }
 function archiveOutputPath3(inputPath) {
-  return import_node_path9.default.join(import_node_path9.default.dirname(inputPath), `${stemOf(inputPath)}${MOSAIC_ARCHIVE_EXTENSION}`);
+  return import_node_path8.default.join(import_node_path8.default.dirname(inputPath), `${stemOf(inputPath)}${MOSAIC_ARCHIVE_EXTENSION}`);
 }
 async function openIfcModel(bytes, options = {}) {
   const module2 = await webIfc();
@@ -97160,18 +97194,18 @@ async function openIfcModel(bytes, options = {}) {
   };
 }
 async function convertIfcFile(inputPath, options = {}) {
-  if (!import_node_fs6.default.existsSync(inputPath)) throw new Error(`File ${inputPath} does not exist`);
-  const source = import_node_path9.default.resolve(inputPath);
-  const model = await openIfcModel(new Uint8Array(import_node_fs6.default.readFileSync(source)), options);
+  if (!import_node_fs7.default.existsSync(inputPath)) throw new Error(`File ${inputPath} does not exist`);
+  const source = import_node_path8.default.resolve(inputPath);
+  const model = await openIfcModel(new Uint8Array(import_node_fs7.default.readFileSync(source)), options);
   try {
     return ifc4ToMosaic(model.api, model.modelID, {
       // Entities that have no GlobalId are keyed within the file they came from, and
       // the file name is the only name that file has.
-      seed: import_node_path9.default.basename(source),
+      seed: import_node_path8.default.basename(source),
       ...options,
       provenance: {
-        id: import_node_path9.default.basename(source),
-        message: `Imported from ${import_node_path9.default.basename(source)}`,
+        id: import_node_path8.default.basename(source),
+        message: `Imported from ${import_node_path8.default.basename(source)}`,
         ...options.provenance
       }
     });
@@ -97180,13 +97214,13 @@ async function convertIfcFile(inputPath, options = {}) {
   }
 }
 function write2(target, data) {
-  import_node_fs6.default.mkdirSync(import_node_path9.default.dirname(target), { recursive: true });
-  import_node_fs6.default.writeFileSync(target, data);
+  import_node_fs7.default.mkdirSync(import_node_path8.default.dirname(target), { recursive: true });
+  import_node_fs7.default.writeFileSync(target, data);
   return typeof data === "string" ? Buffer.byteLength(data) : data.byteLength;
 }
 async function convertIfcToSourceFile(inputPath, outputPath, options) {
   const result = await convertIfcFile(inputPath, options);
-  const target = import_node_path9.default.resolve(outputPath ?? sourceOutputPath2(import_node_path9.default.resolve(inputPath)));
+  const target = import_node_path8.default.resolve(outputPath ?? sourceOutputPath2(import_node_path8.default.resolve(inputPath)));
   return {
     outputPath: target,
     byteLength: write2(target, `${JSON.stringify(result.document, null, 2)}
@@ -97197,7 +97231,7 @@ async function convertIfcToSourceFile(inputPath, outputPath, options) {
 }
 async function convertIfcToArchiveFile(inputPath, outputPath, options) {
   const result = await convertIfcFile(inputPath, options);
-  const target = import_node_path9.default.resolve(outputPath ?? archiveOutputPath3(import_node_path9.default.resolve(inputPath)));
+  const target = import_node_path8.default.resolve(outputPath ?? archiveOutputPath3(import_node_path8.default.resolve(inputPath)));
   return {
     outputPath: target,
     byteLength: write2(target, await packMosaicSource(result.document)),
@@ -97212,7 +97246,7 @@ var NO_GEOMETRY = "--no-geometry";
 var SEED = "--seed=";
 var FLAGS = `[${CENTER}] [${NO_GEOMETRY}] [${SEED}<text>]`;
 var IFC_USAGE = `mosaic ifc <input.ifc> [output${MOSAIC_SOURCE_EXTENSION2}] ${FLAGS}`;
-var IFC_PACK_USAGE = `mosaic ifc-pack <input.ifc> [output.tsr] ${FLAGS}`;
+var IFC_PACK_USAGE = `mosaic pack <input.ifc> [output.tsr] ${FLAGS}`;
 function readArgs2(argv) {
   const seed = argv.find((arg) => arg.startsWith(SEED))?.slice(SEED.length);
   return {
@@ -97226,7 +97260,7 @@ function readArgs2(argv) {
 }
 function report2(inputPath, result) {
   const { stats } = result;
-  console.log(`Converted: ${import_node_path10.default.resolve(inputPath)} -> ${result.outputPath}`);
+  console.log(`Converted: ${import_node_path9.default.resolve(inputPath)} -> ${result.outputPath}`);
   console.log();
   console.log(`Schema: ${stats.schema}`);
   console.log(`Nodes: ${stats.nodes} (${stats.entities} from IFC entities)`);
@@ -97264,13 +97298,13 @@ async function runIfcPack(argv) {
 }
 
 // src/commands/svg.ts
-var import_node_path11 = __toESM(require("node:path"), 1);
-var SVG_PACK_USAGE = `mosaic svg-pack <input.svg> [output.tsr]`;
+var import_node_path10 = __toESM(require("node:path"), 1);
+var SVG_PACK_USAGE = `mosaic pack <input.svg> [output.tsr]`;
 async function runSvgPack(argv) {
   const [input_path, output_path] = argv.filter((arg) => !arg.startsWith("--"));
   if (input_path === void 0) throw new Error(`Usage: ${SVG_PACK_USAGE}`);
   const result = await convertSvgToArchiveFile(input_path, output_path);
-  console.log(`Packed: ${import_node_path11.default.resolve(input_path)} -> ${result.outputPath}`);
+  console.log(`Packed: ${import_node_path10.default.resolve(input_path)} -> ${result.outputPath}`);
   console.log();
   console.log(`Node: ${result.nodeId}`);
   console.log(`Name: ${result.name}`);
@@ -97282,6 +97316,59 @@ async function runSvgPack(argv) {
   console.log(`Wrote ${result.byteLength} bytes.`);
 }
 
+// src/commands/pack.ts
+var PACK_USAGE = `mosaic pack <input.json|.gltf|.glb|.ifc|.svg|url> [output${MOSAIC_ARCHIVE_EXTENSION}] [flags]`;
+var PACK_DETAILS = [
+  `.json, .mosaic.json  a Mosaic source document`,
+  `.gltf, .glb          a glTF model, or an http(s) URL to one   [--stable-ids]`,
+  `.ifc                 an IFC4 / IFC2X3 model                   [--center] [--no-geometry] [--seed=<text>]`,
+  `.svg                 a drawing, as one node`
+];
+function extensionOf(input) {
+  const name = /^https?:\/\//i.test(input) ? new URL(input).pathname : input;
+  return import_node_path11.default.extname(name).toLowerCase();
+}
+async function packSource(argv) {
+  const [input_path, output_path] = argv.filter((arg) => !arg.startsWith("--"));
+  if (input_path === void 0) throw new Error(`Usage: ${PACK_USAGE}`);
+  const result = await packMosaicSourceFile(input_path, output_path);
+  console.log(`Packed: ${import_node_path11.default.resolve(input_path)} -> ${result.outputPath}`);
+  console.log();
+  console.log(`Component tables (${result.componentCount} rows):`);
+  result.tables.forEach((table) => console.log(` - ${table}`));
+  console.log();
+  console.log(`Wrote ${result.byteLength} bytes.`);
+}
+async function runPack(argv) {
+  const input = argv.find((arg) => !arg.startsWith("--"));
+  if (input === void 0) throw new Error(`Usage: ${PACK_USAGE}
+
+  ${PACK_DETAILS.join("\n  ")}`);
+  const isUrl2 = /^https?:\/\//i.test(input);
+  const extension = extensionOf(input);
+  switch (extension) {
+    case ".gltf":
+    case ".glb":
+      return runGltfPack(argv);
+    case ".json":
+      if (isUrl2) break;
+      return packSource(argv);
+    case ".ifc":
+      if (isUrl2) break;
+      return runIfcPack(argv);
+    case ".svg":
+      if (isUrl2) break;
+      return runSvgPack(argv);
+    default:
+      throw new Error(
+        `Cannot pack ${input}: ${extension ? `"${extension}" is not` : "no extension says what it is, and it is not"} a format mosaic reads.
+
+  ${PACK_DETAILS.join("\n  ")}`
+      );
+  }
+  throw new Error(`Cannot pack ${input}: only glTF (.gltf, .glb) can be packed from a URL. Download it first and pack the file.`);
+}
+
 // src/commands/compose.ts
 var import_node_path15 = __toESM(require("node:path"), 1);
 var DATABASE_EXTENSIONS = [".duckdb", ".db", ".ddb"];
@@ -97409,7 +97496,7 @@ async function runServe(argv) {
 }
 
 // src/mosaic.ts
-var VERSION = true ? "0.1.0" : "dev";
+var VERSION = true ? "0.2.0" : "dev";
 var COMMANDS = {
   codegen: {
     usage: CODEGEN_USAGE,
@@ -97418,7 +97505,8 @@ var COMMANDS = {
   },
   pack: {
     usage: PACK_USAGE,
-    summary: "Pack a Mosaic source document into a .tsr archive",
+    details: PACK_DETAILS,
+    summary: "Pack a source document, glTF, IFC or SVG into a .tsr archive",
     run: runPack
   },
   gltf: {
@@ -97426,26 +97514,11 @@ var COMMANDS = {
     summary: "Convert a glTF or GLB file into a Mosaic source document",
     run: runGltf
   },
-  "gltf-pack": {
-    usage: GLTF_PACK_USAGE,
-    summary: "Convert a glTF or GLB file straight into a .tsr archive",
-    run: runGltfPack
-  },
   ifc: {
     usage: IFC_USAGE,
     summary: "Convert an IFC model into a Mosaic source document",
     run: runIfc
   },
-  "ifc-pack": {
-    usage: IFC_PACK_USAGE,
-    summary: "Convert an IFC model straight into a .tsr archive",
-    run: runIfcPack
-  },
-  "svg-pack": {
-    usage: SVG_PACK_USAGE,
-    summary: "Pack an SVG into a .tsr archive of one node",
-    run: runSvgPack
-  },
   compose: {
     usage: COMPOSE_USAGE,
     summary: "Compose an archive and its imports into a renderable .glb",
@@ -97466,6 +97539,7 @@ function printUsage() {
   for (const [name, command] of Object.entries(COMMANDS)) {
     console.log(`  ${name.padEnd(10)} ${command.summary}`);
     console.log(`  ${" ".repeat(10)} ${command.usage}`);
+    for (const line of command.details ?? []) console.log(`  ${" ".repeat(12)} ${line}`);
   }
   console.log();
   console.log(`  help       Show this message`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomvandig/mosaic",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "The Mosaic CLI: pack, convert (glTF, IFC, SVG), compose and serve Mosaic archives",
   "license": "UNLICENSED",
   "keywords": [