@field/cascade 0.10.0 → 0.12.0

package/dist/cli/chunk-NJFMDXHR.js

@@ -0,0 +1,320 @@
+import {
+  isGeometrySerialized
+} from "./chunk-J7VK7MNF.js";
+import {
+  CORE_TYPES
+} from "./chunk-FWMSGKEH.js";
+
+// packages/contracts/src/validate.ts
+var IDENTIFIER = /^[A-Za-z][A-Za-z0-9_]*$/;
+var NAMESPACED = /^[a-z][a-z0-9-]*(?:\.[A-Za-z][A-Za-z0-9_]*)+$/;
+var RESERVED = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+var CORE = new Set(CORE_TYPES);
+var CONTROLS = /* @__PURE__ */ new Set(["number", "slider", "range", "int", "boolean", "text", "textarea", "select", "vector", "matrix", "color", "image", "asset"]);
+var CAPABILITIES_BY_ENVIRONMENT = {
+  portable: ["assets", "media", "gpu"],
+  browser: ["assets", "media", "gpu"],
+  server: ["files", "assets", "media", "python", "shell", "gpu"]
+};
+var ALLOWED = CAPABILITIES_BY_ENVIRONMENT;
+var fields = (names) => new Set(names.split(" "));
+var TOP_FIELDS = fields(
+  "apiVersion runsOn container capabilities gpuLimits source label description icon inputs outputs props"
+);
+var DATA_FIELDS = fields(
+  "kind type default description variadic min max step accept control options schema fields"
+);
+var OUTPUT_FIELDS = fields("kind type description schema fields");
+var PROP_FIELDS = fields(
+  "type default label description min max step accept control options expression action"
+);
+function diagnostic(code, message, path) {
+  return { phase: "definition", code: `definition/${code}`, message, path };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validType(type) {
+  return typeof type === "string" && (CORE.has(type) || NAMESPACED.test(type));
+}
+function finiteJson(value) {
+  if (value === null || typeof value === "string" || typeof value === "boolean")
+    return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (Array.isArray(value)) return value.every(finiteJson);
+  return isRecord(value) && Object.values(value).every(finiteJson);
+}
+function unknownFields(value, allowed, path) {
+  return Object.keys(value).filter((key) => !allowed.has(key)).map(
+    (key) => diagnostic(
+      "unknown-field",
+      `${path}.${key} is not allowed`,
+      `${path}.${key}`
+    )
+  );
+}
+function defaultMatches(type, value) {
+  if (!finiteJson(value)) return false;
+  if (type === "geometry") return isGeometrySerialized(value);
+  if (type === "float") return typeof value === "number";
+  if (type === "int") return typeof value === "number";
+  if (type === "bool") return typeof value === "boolean";
+  if (type === "string") return typeof value === "string";
+  const lengths = {
+    vec2: 2,
+    vec3: 3,
+    vec4: 4,
+    vec2i: 2,
+    vec3i: 3,
+    vec4i: 4,
+    mat2: 4,
+    mat3: 9,
+    mat4: 16,
+    color: 4
+  };
+  const length = lengths[type];
+  return length === void 0 || Array.isArray(value) && value.length === length && value.every(
+    (item) => type.endsWith("i") ? Number.isInteger(item) : typeof item === "number"
+  );
+}
+function validateNodeDefinition(value) {
+  if (!isRecord(value))
+    return [diagnostic("not-object", "Definition must be an object")];
+  const result = unknownFields(value, TOP_FIELDS, "definition");
+  const add = (code, message, path) => result.push(diagnostic(code, message, path));
+  const environment = value.runsOn;
+  if (value.apiVersion !== 1)
+    add("api-version", "apiVersion must be 1", "apiVersion");
+  if (!Object.prototype.hasOwnProperty.call(ALLOWED, String(environment)))
+    add("environment", "runsOn must be portable, browser, or server", "runsOn");
+  if (value.container !== void 0 && value.container !== "subnet" && value.container !== "feedback")
+    add("invalid-container", "container must be subnet or feedback", "container");
+  if (value.source !== void 0 && value.source !== "live")
+    add("invalid-source", 'source must be "live" when present', "source");
+  const allowed = ALLOWED[environment] ?? [];
+  if (value.capabilities !== void 0 && !Array.isArray(value.capabilities))
+    add(
+      "invalid-capabilities",
+      "capabilities must be an array",
+      "capabilities"
+    );
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, capability] of (Array.isArray(value.capabilities) ? value.capabilities : []).entries()) {
+    const path = `capabilities.${index}`;
+    if (!seen.has(capability) && !allowed.includes(capability))
+      add(
+        "capability-not-allowed",
+        `${String(capability)} is not available on ${String(environment)}`,
+        path
+      );
+    if (seen.has(capability))
+      add("duplicate-capability", `${String(capability)} is duplicated`, path);
+    seen.add(capability);
+  }
+  if (value.gpuLimits !== void 0) {
+    if (!seen.has("gpu"))
+      add("gpu-limits-without-gpu", "gpuLimits needs the gpu capability", "gpuLimits");
+    if (!isRecord(value.gpuLimits))
+      add("invalid-gpu-limits", "gpuLimits must be an object of WebGPU limit names to numbers", "gpuLimits");
+    else
+      for (const [name, limit] of Object.entries(value.gpuLimits))
+        if (typeof limit !== "number" || !Number.isFinite(limit) || limit < 0)
+          add("invalid-gpu-limits", `gpuLimits.${name} must be a non-negative number`, `gpuLimits.${name}`);
+  }
+  const inward = /* @__PURE__ */ new Map();
+  const outward = /* @__PURE__ */ new Map();
+  for (const section of ["inputs", "outputs", "props"]) {
+    const entries = value[section];
+    if (entries === void 0) continue;
+    if (!isRecord(entries)) {
+      add("invalid-section", `${section} must be an object`, section);
+      continue;
+    }
+    for (const [name, raw] of Object.entries(entries)) {
+      const path = `${section}.${name}`;
+      if (!IDENTIFIER.test(name))
+        add("invalid-name", `${name} is not a valid identifier`, path);
+      if (RESERVED.has(name)) add("reserved-name", `${name} is reserved`, path);
+      const names = section === "outputs" ? outward : inward;
+      const previous = names.get(name);
+      if (previous)
+        add(
+          "name-collision",
+          `${name} is declared in ${previous} and ${section}`,
+          path
+        );
+      else names.set(name, section);
+      if (!isRecord(raw)) {
+        add("invalid-entry", `${path} must be an object`, path);
+        continue;
+      }
+      const fields2 = section === "props" ? PROP_FIELDS : section === "outputs" ? OUTPUT_FIELDS : DATA_FIELDS;
+      if (section !== "props" && raw.kind !== "data" && raw.kind !== "trigger") {
+        add(
+          "invalid-kind",
+          `${path}.kind must be data or trigger`,
+          `${path}.kind`
+        );
+        result.push(...unknownFields(raw, fields2, path));
+        continue;
+      }
+      if (section !== "props" && raw.kind === "trigger") {
+        if (Object.keys(raw).some(
+          (key) => key !== "kind" && key !== "description"
+        ))
+          add(
+            "trigger-extra",
+            "Trigger ports allow only kind and description",
+            path
+          );
+        continue;
+      }
+      result.push(...unknownFields(raw, fields2, path));
+      if ("control" in raw && (typeof raw.control !== "string" || !CONTROLS.has(raw.control)))
+        add(
+          "invalid-control",
+          `${String(raw.control)} is not a Cascade control`,
+          `${path}.control`
+        );
+      if ("options" in raw && raw.control !== "select")
+        add(
+          "options-without-select",
+          "options require the select control",
+          `${path}.options`
+        );
+      if (Array.isArray(raw.options))
+        for (const [index, option] of raw.options.entries()) {
+          if (option === null || typeof option !== "object") continue;
+          const entry = option;
+          if (!("value" in entry))
+            add(
+              "invalid-option",
+              "a labelled option needs a value",
+              `${path}.options[${index}]`
+            );
+          if (typeof entry.label !== "string" || !entry.label)
+            add(
+              "invalid-option",
+              "a labelled option needs a non-empty label",
+              `${path}.options[${index}].label`
+            );
+          if ("disabled" in entry && typeof entry.disabled !== "boolean")
+            add(
+              "invalid-option",
+              "disabled must be a boolean",
+              `${path}.options[${index}].disabled`
+            );
+        }
+      const type = raw.type;
+      if (!validType(type)) {
+        add(
+          "invalid-type",
+          `${String(type)} is not a Cascade type`,
+          `${path}.type`
+        );
+        continue;
+      }
+      if (section !== "props") result.push(...bundleDiagnostics(raw, type, section, path));
+      if (type === "texture" && environment !== "browser")
+        add("texture-not-portable", "texture is browser-only", `${path}.type`);
+      if (type === "texture" && "default" in raw)
+        add(
+          "texture-default",
+          "texture cannot have a default",
+          `${path}.default`
+        );
+      if (section === "props" && !("default" in raw))
+        add("missing-default", "Props require defaults", `${path}.default`);
+      if ("default" in raw && !finiteJson(raw.default))
+        add(
+          "invalid-default",
+          "Default must be finite JSON",
+          `${path}.default`
+        );
+      else if ("default" in raw && !defaultMatches(type, raw.default))
+        add(
+          "default-type",
+          `Default does not match ${type}`,
+          `${path}.default`
+        );
+      if (type === "int" && "default" in raw && (!Number.isFinite(raw.default) || !Number.isInteger(raw.default)))
+        add(
+          "non-integer",
+          "Integer defaults must be finite integers",
+          `${path}.default`
+        );
+      if ("step" in raw && (typeof raw.step !== "number" || !Number.isFinite(raw.step) || raw.step <= 0))
+        add("invalid-step", "step must be greater than zero", `${path}.step`);
+      if (section === "props" && "expression" in raw && (typeof raw.expression !== "string" || raw.expression.length === 0))
+        add(
+          "invalid-expression",
+          "expression must be a non-empty string",
+          `${path}.expression`
+        );
+      for (const field of ["min", "max"]) {
+        if (field in raw && (typeof raw[field] !== "number" || !Number.isFinite(raw[field])))
+          add(
+            `invalid-${field}`,
+            `${field} must be a finite number`,
+            `${path}.${field}`
+          );
+      }
+      if (typeof raw.min === "number" && typeof raw.max === "number" && raw.min > raw.max)
+        add("invalid-range", "min must not exceed max", path);
+    }
+  }
+  return result;
+}
+function bundleDiagnostics(raw, type, section, path) {
+  const result = [];
+  const add = (code, message, at) => result.push(diagnostic(code, message, at));
+  for (const key of ["schema", "fields"])
+    if (key in raw && type !== "bundle")
+      add("bundle-metadata", `${key} is only valid on a bundle port`, `${path}.${key}`);
+  if (type !== "bundle") return result;
+  if ("schema" in raw && (typeof raw.schema !== "string" || !IDENTIFIER.test(raw.schema)))
+    add("invalid-schema", "schema must be an identifier", `${path}.schema`);
+  if (!("fields" in raw)) return result;
+  const declared = raw.fields;
+  if (section === "inputs") {
+    if (!Array.isArray(declared)) {
+      add("invalid-fields", "an input's fields list the field names it reads", `${path}.fields`);
+      return result;
+    }
+    const seen = /* @__PURE__ */ new Set();
+    for (const [index, field] of declared.entries()) {
+      if (typeof field !== "string" || !IDENTIFIER.test(field))
+        add("invalid-field", `${String(field)} is not a valid field name`, `${path}.fields[${index}]`);
+      else if (seen.has(field))
+        add("duplicate-field", `${field} is listed twice`, `${path}.fields[${index}]`);
+      else seen.add(field);
+    }
+    return result;
+  }
+  if (!isRecord(declared)) {
+    add("invalid-fields", "an output's fields map each field name to its type", `${path}.fields`);
+    return result;
+  }
+  for (const [field, definition] of Object.entries(declared)) {
+    const at = `${path}.fields.${field}`;
+    if (!IDENTIFIER.test(field) || RESERVED.has(field))
+      add("invalid-field", `${field} is not a valid field name`, at);
+    const fieldType = typeof definition === "string" ? definition : isRecord(definition) ? definition.type : void 0;
+    if (isRecord(definition)) {
+      for (const key of Object.keys(definition))
+        if (key !== "type" && key !== "description")
+          add("unknown-field", `${at}.${key} is not allowed`, `${at}.${key}`);
+    }
+    if (!validType(fieldType))
+      add("invalid-type", `${String(fieldType)} is not a Cascade type`, at);
+    else if (fieldType === "texture")
+      add("texture-not-portable", "a bundle field cannot hold a texture", at);
+  }
+  return result;
+}
+
+export {
+  CAPABILITIES_BY_ENVIRONMENT,
+  validateNodeDefinition
+};
+//# sourceMappingURL=chunk-NJFMDXHR.js.map

package/dist/cli/chunk-OM6BEME6.js

@@ -0,0 +1,267 @@
+import {
+  createRuntime,
+  moduleId,
+  projectModuleFile,
+  validateNodeModuleArchitecture
+} from "./chunk-MP653A5O.js";
+import {
+  builtinNodeRegistration
+} from "./chunk-MI5JLQYA.js";
+import {
+  ProjectRoot,
+  extractNodeDefinition
+} from "./chunk-2JEU3MGB.js";
+
+// src/cli/webBuild.ts
+import fs from "node:fs/promises";
+import path from "node:path";
+import { builtinModules } from "node:module";
+import { fileURLToPath } from "node:url";
+import { build } from "esbuild";
+import ts from "typescript";
+
+// packages/runtime/src/browser.ts
+function createBrowserRuntimeHost(options) {
+  const {
+    modules,
+    legacyShell,
+    now = () => Date.now(),
+    report = () => {
+    },
+    ...capabilities
+  } = options;
+  return {
+    environment: "browser",
+    modules,
+    legacyShell,
+    capabilities,
+    now,
+    report
+  };
+}
+
+// src/cli/webBuild.ts
+var installRoot = fileURLToPath(new URL("../../", import.meta.url));
+var forbiddenModules = new Set(builtinModules.map((name) => name.replace(/^node:/, "")));
+async function buildPlayer(file, options) {
+  if (!options.out) throw new Error("cascade build requires --out <new-directory>");
+  const project = new ProjectRoot(path.dirname(path.resolve(file)));
+  const out = path.resolve(project.root, options.out);
+  if (await exists(out)) throw new Error(`Player output already exists: ${out}. Choose a new directory.`);
+  const canonicalOut = await canonicalFuturePath(out);
+  for (const sourceDirectory of ["assets", "nodes"]) {
+    const sourceRoot = await canonicalFuturePath(path.join(project.root, sourceDirectory));
+    if (inside(sourceRoot, canonicalOut)) {
+      throw new Error(`Player output cannot be inside the project's ${sourceDirectory} directory`);
+    }
+  }
+  const document = JSON.parse(await fs.readFile(file, "utf8"));
+  if (!Array.isArray(document.nodes)) throw new Error("Graph document must contain a nodes array");
+  const modules = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const node of document.nodes) {
+    const id = moduleId(node);
+    if (seen.has(id)) continue;
+    seen.add(id);
+    if (builtinNodeRegistration(id)) continue;
+    const resolved = await projectModuleFile(project.root, node, id);
+    if (!resolved.file) throw new Error(`${id}: no supported static project module (${resolved.tried.join(", ")})`);
+    const sourceFile = project.resolve(path.relative(project.root, resolved.file));
+    const source = await fs.readFile(sourceFile, "utf8");
+    const extracted = extractNodeDefinition(source, sourceFile, ts);
+    if (!extracted.ok) throw new Error(`${id}: static browser builds require definition-v1
+${extracted.diagnostics.map((d) => `${d.code}: ${d.message}`).join("\n")}`);
+    const diagnostics = validateNodeModuleArchitecture(source, sourceFile, ts);
+    if (diagnostics.length) throw new Error(diagnostics.map((d) => `${id}: ${d.code}: ${d.message}`).join("\n"));
+    modules.push({ id, file: sourceFile, definition: extracted.definition });
+  }
+  const registrations = modules.map((item) => ({
+    kind: "definition-v1",
+    moduleId: item.id,
+    definition: item.definition,
+    loadExecute: async () => {
+      throw new Error("Static builds never execute project code");
+    }
+  }));
+  const runtime = createRuntime({ host: createBrowserRuntimeHost({
+    modules: { resolve: async (id) => registrations.find((item) => item.moduleId === id) ?? null },
+    // Presence describes the exported player contract, not this Node process.
+    assets: {},
+    gpu: {}
+  }), nodes: registrations });
+  const assets = new Set(options.assets ?? []);
+  try {
+    const graph = await runtime.load(document);
+    const diagnostics = graph.preflight();
+    if (diagnostics.length) throw new Error(`This graph cannot be exported to the browser player:
+${diagnostics.map((d) => `${d.path ?? ""} ${d.code}: ${d.message}`).join("\n")}`);
+    for (const node of graph.inspect().nodes) {
+      for (const port of [...Object.values(node.inputs), ...Object.values(node.props)]) {
+        if (port.type !== "image" && port.type !== "asset") continue;
+        const value = port.value;
+        const asset = typeof value === "string" ? value : value && typeof value === "object" && "path" in value ? value.path : void 0;
+        if (typeof asset === "string" && asset && !/^(https?:|data:|blob:)/.test(asset)) assets.add(asset);
+      }
+    }
+  } finally {
+    await runtime.dispose();
+  }
+  const sources = [];
+  for (const asset of assets) {
+    const name = asset.replace(/^\.\//, "");
+    if (!name || name.includes("\\") || name.split("/").some((part) => !part || part.startsWith(".")) || path.isAbsolute(name)) {
+      throw new Error(`Asset must be a visible project-relative file: ${asset}`);
+    }
+    const source = project.resolve(name);
+    if (!(await fs.stat(source)).isFile()) throw new Error(`Asset is not a file: ${asset}`);
+    sources.push({ name, file: source });
+  }
+  const playerApp = await playerFile("app");
+  const playerEmbed = await playerFile("embed");
+  const plugins = [await staticRuntimePlugin(project.root)];
+  const imports = modules.map((item, index) => `import { execute as execute${index} } from ${JSON.stringify(item.file)};`).join("\n");
+  const registrationSource = modules.map((item, index) => `{ kind:'definition-v1', moduleId:${JSON.stringify(item.id)}, definition:${JSON.stringify(item.definition)}, loadExecute:async()=>execute${index} }`).join(",");
+  const assetSource = sources.map((item) => `${JSON.stringify(item.name)}:new URL(${JSON.stringify(`./assets/${item.name.split("/").map(encodeURIComponent).join("/")}`)},import.meta.url).href`).join(",");
+  const appSource = `import { startPlayer } from ${JSON.stringify(playerApp)};
+${imports}
+window.cascadePlayerReady = startPlayer({document:${JSON.stringify(document)},registrations:[${registrationSource}],assets:{${assetSource}}});
+window.cascadePlayerReady.catch(error=>{const message=document.createElement('pre');message.textContent=String(error?.message??error);document.body.append(message);});`;
+  const embedSource = `import { mountPlayer } from ${JSON.stringify(playerEmbed)};
+export function mount(container,options={}) { return mountPlayer(container,{...options,url:new URL('./player.html',import.meta.url)}); }`;
+  const common = {
+    bundle: true,
+    platform: "browser",
+    format: "esm",
+    target: "es2022",
+    write: false,
+    minify: true,
+    logLevel: "silent",
+    plugins
+  };
+  const app = await build({ ...common, stdin: { contents: appSource, resolveDir: project.root, sourcefile: "player-entry.js" } });
+  const embed = await build({ ...common, stdin: { contents: embedSource, resolveDir: project.root, sourcefile: "embed-entry.js" } });
+  await fs.mkdir(path.dirname(out), { recursive: true });
+  const staging = await fs.mkdtemp(path.join(path.dirname(out), ".cascade-player-"));
+  try {
+    const html = '<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Cascade</title><style>html,body{margin:0;width:100%;height:100%;overflow:hidden}body{font:13px system-ui}pre{white-space:pre-wrap;padding:16px}</style></head><body><script type="module" src="./app.js"></script></body></html>';
+    await fs.writeFile(path.join(staging, "index.html"), html);
+    await fs.writeFile(path.join(staging, "player.html"), html);
+    await fs.writeFile(path.join(staging, "app.js"), app.outputFiles[0].contents);
+    await fs.writeFile(path.join(staging, "embed.js"), embed.outputFiles[0].contents);
+    for (const source of sources) {
+      const target = path.join(staging, "assets", source.name);
+      await fs.mkdir(path.dirname(target), { recursive: true });
+      await fs.copyFile(source.file, target);
+    }
+    await fs.mkdir(out);
+    try {
+      for (const entry of await fs.readdir(staging)) await fs.rename(path.join(staging, entry), path.join(out, entry));
+    } catch (error) {
+      await fs.rm(out, { recursive: true, force: true });
+      throw error;
+    }
+  } finally {
+    await fs.rm(staging, { recursive: true, force: true });
+  }
+  return { directory: out };
+}
+async function playerFile(name) {
+  const source = path.join(installRoot, "src", "player", `${name}.ts`);
+  return await exists(source) ? source : path.join(installRoot, "dist", "player", `${name}.js`);
+}
+async function staticRuntimePlugin(projectRoot) {
+  const manifest = JSON.parse(await fs.readFile(path.join(installRoot, "package.json"), "utf8"));
+  const canonicalProjectRoot = await fs.realpath(projectRoot);
+  const confinementMarker = /* @__PURE__ */ Symbol("cascade-player-confinement");
+  return { name: "cascade-static-player", setup(builder) {
+    builder.onResolve({ filter: /.*/ }, async (args) => {
+      const marked = typeof args.pluginData === "object" && args.pluginData !== null && args.pluginData[confinementMarker] === true;
+      if (!marked && isFilesystemImport(args.path) && await importerIsInProject(args.importer, canonicalProjectRoot)) {
+        const resolved = await builder.resolve(args.path, {
+          importer: args.importer,
+          resolveDir: args.resolveDir,
+          kind: args.kind,
+          pluginData: { [confinementMarker]: true }
+        });
+        if (resolved.errors.length || !resolved.path || resolved.external) return resolved;
+        const canonicalTarget = await fs.realpath(resolved.path);
+        if (!inside(canonicalProjectRoot, canonicalTarget)) {
+          return { errors: [{
+            text: `Project import escapes the project: ${args.path} resolves to ${canonicalTarget}`
+          }] };
+        }
+        return resolved;
+      }
+      if (args.path.startsWith("node:") || forbiddenModules.has(args.path)) {
+        return { errors: [{ text: `Browser player cannot import Node module ${args.path}` }] };
+      }
+      const canonical = args.path.replace(/^@field\/cascade\//, "cascade/").replace(/^@cascade\//, "cascade/");
+      if (!canonical.startsWith("cascade/")) return;
+      const subpath = canonical.slice("cascade/".length);
+      if (!(subpath === "io" || subpath === "image" || subpath === "gpu" || subpath === "contracts" || subpath.startsWith("contracts/") || subpath === "runtime" || subpath.startsWith("runtime/"))) {
+        return { errors: [{ text: `Browser player cannot import ${args.path}; server transports and configuration are not exported` }] };
+      }
+      if (subpath === "runtime/node" || subpath === "runtime/definition/extract") {
+        return { errors: [{ text: `Browser player cannot import ${args.path}` }] };
+      }
+      const entry = manifest.exports[`./${subpath}`]?.default;
+      if (!entry) return { errors: [{ text: `Unknown Cascade browser export: ${args.path}` }] };
+      const sourceShim = path.join(installRoot, "server", "src", "runtime", `${subpath}.ts`);
+      return { path: (subpath === "io" || subpath === "image" || subpath === "gpu") && await exists(sourceShim) ? sourceShim : path.resolve(installRoot, entry) };
+    });
+  } };
+}
+function isFilesystemImport(specifier) {
+  return specifier.startsWith(".") || path.isAbsolute(specifier);
+}
+async function importerIsInProject(importer, canonicalProjectRoot) {
+  if (!importer || !path.isAbsolute(importer)) return false;
+  try {
+    return inside(canonicalProjectRoot, await fs.realpath(importer));
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  }
+}
+async function canonicalFuturePath(candidate) {
+  let existing = path.resolve(candidate);
+  const missing = [];
+  for (; ; ) {
+    try {
+      await fs.lstat(existing);
+      break;
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+      const parent = path.dirname(existing);
+      if (parent === existing) throw new Error(`Output path has no accessible parent: ${candidate}`);
+      missing.unshift(path.basename(existing));
+      existing = parent;
+    }
+  }
+  return path.resolve(await fs.realpath(existing), ...missing);
+}
+function inside(root, candidate) {
+  const relative = path.relative(root, candidate);
+  return relative === "" || !relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative);
+}
+async function exists(file) {
+  try {
+    await fs.lstat(file);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  }
+}
+
+export {
+  createBrowserRuntimeHost,
+  installRoot,
+  buildPlayer,
+  playerFile,
+  staticRuntimePlugin,
+  canonicalFuturePath,
+  inside,
+  exists
+};
+//# sourceMappingURL=chunk-OM6BEME6.js.map