@forgeax/engine-shader 0.0.0-dev.8d955ade1c79

package/dist/index.mjs

@@ -0,0 +1,557 @@
+import { ok, err, ParamSchemaProjectionOwner, findUndeclaredSampledTextures } from '@forgeax/engine-types';
+export { MATERIAL_PARAM_TYPES } from '@forgeax/engine-types';
+import { ok as ok$1, err as err$1 } from '@forgeax/engine-rhi';
+export { err, ok } from '@forgeax/engine-rhi';
+
+// src/material-schemas.ts
+var STANDARD_PBR_ALPHA_CUTOFF_DEFAULT = 0;
+var DEFAULT_STANDARD_PBR_PARAM_SCHEMA = [
+  { name: "baseColor", type: "color", default: [1, 1, 1, 1] },
+  { name: "metallic", type: "f32", default: 0 },
+  { name: "roughness", type: "f32", default: 0.5 },
+  { name: "metallicChannel", type: "f32", default: 2 },
+  { name: "roughnessChannel", type: "f32", default: 1 },
+  { name: "aoChannel", type: "f32", default: 0 },
+  { name: "extraChannel", type: "f32", default: 0 },
+  { name: "emissive", type: "vec3", colorSpace: "srgb", default: [0, 0, 0] },
+  { name: "emissiveIntensity", type: "f32", default: 0 },
+  { name: "occlusionStrength", type: "f32", default: 1 },
+  { name: "alphaCutoff", type: "f32", default: STANDARD_PBR_ALPHA_CUTOFF_DEFAULT },
+  { name: "clearcoat", type: "f32", default: 0 },
+  { name: "clearcoatRoughness", type: "f32", default: 0.5 },
+  { name: "specularTint", type: "vec3", colorSpace: "srgb", default: [1, 1, 1] },
+  { name: "normalScale", type: "f32", default: 1 },
+  { name: "baseColorTexture", type: "texture2d" },
+  { name: "metallicRoughnessTexture", type: "texture2d" },
+  { name: "normalTexture", type: "texture2d" },
+  { name: "specularTintTexture", type: "texture2d" },
+  { name: "emissiveTexture", type: "texture2d" },
+  { name: "occlusionTexture", type: "texture2d" }
+];
+var DEFAULT_UNLIT_PARAM_SCHEMA = [
+  { name: "baseColor", type: "color", default: [1, 1, 1, 1] },
+  { name: "alphaCutoff", type: "f32", default: 0 },
+  { name: "baseColorTexture", type: "texture2d" }
+];
+var DEFAULT_SPRITE_PARAM_SCHEMA = [
+  { name: "colorTint", type: "vec4", colorSpace: "srgb", default: [1, 1, 1, 1] },
+  { name: "region", type: "vec4", default: [0, 0, 1, 1] },
+  { name: "pivotAndSize", type: "vec4", default: [0.5, 0.5, 1, 1] },
+  { name: "slicesAndMode", type: "vec4", default: [0, 0, 0, 0] },
+  { name: "baseColorTexture", type: "texture2d" }
+];
+var DEFAULT_MSDF_TEXT_PARAM_SCHEMA = [
+  { name: "tintColor", type: "color", default: [1, 1, 1, 1] },
+  { name: "distanceRange", type: "vec4", default: [4, 512, 512, 0] },
+  { name: "baseColorTexture", type: "texture2d" }
+];
+var ShaderError = class extends Error {
+  name = "ShaderError";
+  code;
+  expected;
+  hint;
+  lineNum;
+  linePos;
+  detail;
+  constructor(init) {
+    super(init.message);
+    this.code = init.code;
+    this.expected = init.expected;
+    this.hint = init.hint;
+    this.lineNum = init.lineNum;
+    this.linePos = init.linePos;
+    this.detail = init.detail;
+  }
+};
+function manifestMalformed(args) {
+  return new ShaderError({
+    code: "manifest-malformed",
+    expected: "manifest.json parses + every entry has {hash, wgsl, glsl, bindings}",
+    message: args.message,
+    hint: args.hint,
+    ...args.reason !== void 0 ? { detail: { reason: args.reason } } : {}
+  });
+}
+function shaderNotFound(args) {
+  return new ShaderError({
+    code: "shader-not-found",
+    expected: `manifest.entries contains entry with hash '${args.hash}'`,
+    message: `ShaderRegistry: hash '${args.hash}' not present in manifest`,
+    hint: args.hint
+  });
+}
+function materialShaderNotFound(args) {
+  return new ShaderError({
+    code: "material-shader-not-found",
+    expected: `ShaderRegistry has registered identifiers: [${args.expected.join(", ")}]`,
+    message: `ShaderRegistry: material shader identifier '${args.identifier}' not registered`,
+    hint: args.hint,
+    detail: { reason: `identifier=${args.identifier}`, registeredShaderIds: args.expected }
+  });
+}
+function equalBytes(left, right) {
+  return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+var MaterialArtifactRegistry = class {
+  #artifacts = /* @__PURE__ */ new Map();
+  register(artifact) {
+    const previous = this.#artifacts.get(artifact.key);
+    if (previous !== void 0) {
+      if (equalBytes(previous.bytes, artifact.bytes)) return ok(previous);
+      return err({
+        code: "material-artifact-conflict",
+        expected: "one immutable artifact byte sequence per specialization key",
+        hint: "re-cook the conflicting specialization and publish one artifact digest",
+        detail: {
+          key: artifact.key,
+          ...previous.digest ? { existingDigest: previous.digest } : {},
+          ...artifact.digest ? { incomingDigest: artifact.digest } : {}
+        }
+      });
+    }
+    const immutable = Object.freeze(artifact);
+    this.#artifacts.set(artifact.key, immutable);
+    return ok(immutable);
+  }
+  get(key) {
+    return this.#artifacts.get(key);
+  }
+  inspect(key) {
+    const artifact = this.#artifacts.get(key);
+    if (artifact === void 0) return void 0;
+    return {
+      key: artifact.key,
+      ...artifact.digest === void 0 ? {} : { digest: artifact.digest },
+      byteLength: artifact.bytes.byteLength,
+      ...artifact.metadata === void 0 ? {} : { metadata: artifact.metadata }
+    };
+  }
+};
+
+// src/material/artifact-types.ts
+function isMaterialShaderArtifact(value) {
+  if (value === null || typeof value !== "object") return false;
+  const artifact = value;
+  return typeof artifact.material === "string" && typeof artifact.pass === "string" && typeof artifact.wgsl === "string" && typeof artifact.layoutIdentity === "string" && Array.isArray(artifact.bindings) && Array.isArray(artifact.deps) && Array.isArray(artifact.vertexInputs);
+}
+
+// src/register-default-sprite-lit.ts
+var RESERVED_ID = "forgeax::sprite-lit";
+function registerDefaultSpriteLit(registry, composedWgsl, caps) {
+  registry.installMaterialArtifact(RESERVED_ID, {
+    source: composedWgsl,
+    paramSchema: DEFAULT_SPRITE_PARAM_SCHEMA
+  });
+}
+
+// src/register-default-standard-pbr-skin.ts
+var RESERVED_ID2 = "forgeax::pbr-skin";
+function registerDefaultStandardPbrSkin(registry, composedWgsl, caps) {
+  registry.installMaterialArtifact(RESERVED_ID2, {
+    source: composedWgsl,
+    paramSchema: DEFAULT_STANDARD_PBR_PARAM_SCHEMA
+  });
+}
+var FORGEAX_RESERVED_PATH_PREFIX = "forgeax::";
+var ShaderRegistry = class {
+  #device;
+  #manifestUrl;
+  // hash → ManifestEntry index (populated after loadManifest).
+  #entries = /* @__PURE__ */ new Map();
+  // hash → ShaderModule cache (populated lazily on first get()).
+  #moduleCache = /* @__PURE__ */ new Map();
+  // identifier → MaterialShaderEntry index (populated by
+  // installMaterialArtifact; feat-20260523-shader-template-instance-split M5 / T05).
+  #materialShaders = /* @__PURE__ */ new Map();
+  #paramSchemaProjectionOwner = new ParamSchemaProjectionOwner();
+  #materialShaderManifestEntries = [];
+  #manifestLoaded = false;
+  constructor(opts) {
+    this.#device = opts.device;
+    this.#manifestUrl = opts.manifestUrl;
+  }
+  /**
+   * Loads manifest.json and populates the hash → ManifestEntry index.
+   *
+   * Failure paths (charter proposition 4: explicit failure):
+   * - fetch / data: URL parse failed → `Result.err(ShaderError.manifest-malformed)`
+   * - JSON.parse failed → ditto
+   * - schema missing the `entries` field / an entries element missing
+   *   hash/wgsl/bindings → ditto
+   * - a material shader row is incomplete → ditto
+   *
+   * Validation is atomic: the registry does not publish any entry or
+   * material shader row until the complete document has been validated.
+   *
+   * Idempotent: subsequent calls reuse the first result (never re-fetch;
+   * charter proposition 6: idempotency).
+   */
+  async loadManifest() {
+    if (this.#manifestLoaded) return ok$1(void 0);
+    if (this.#manifestUrl === void 0) {
+      this.#manifestLoaded = true;
+      return ok$1(void 0);
+    }
+    let raw;
+    try {
+      const response = await fetch(this.#manifestUrl);
+      raw = await response.text();
+    } catch (e) {
+      return err$1(
+        manifestMalformed({
+          message: `ShaderRegistry: failed to fetch manifest at ${this.#manifestUrl}`,
+          hint: "verify manifest URL is reachable; check bundler emitFile output path",
+          reason: e instanceof Error ? e.message : String(e)
+        })
+      );
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (e) {
+      return err$1(
+        manifestMalformed({
+          message: "ShaderRegistry: manifest JSON parse failed",
+          hint: "manifest.json must be valid JSON; rebuild via @forgeax/engine-vite-plugin-shader generateBundle",
+          reason: e instanceof Error ? e.message : String(e)
+        })
+      );
+    }
+    if (typeof parsed !== "object" || parsed === null || !("entries" in parsed)) {
+      return err$1(
+        manifestMalformed({
+          message: "ShaderRegistry: manifest missing required `entries` field",
+          hint: "manifest schema requires top-level `entries: ManifestEntry[]`"
+        })
+      );
+    }
+    const entries = parsed.entries;
+    if (!Array.isArray(entries)) {
+      return err$1(
+        manifestMalformed({
+          message: "ShaderRegistry: manifest.entries is not an array",
+          hint: "manifest schema requires `entries: ManifestEntry[]`"
+        })
+      );
+    }
+    const validatedEntries = [];
+    for (const entry of entries) {
+      if (!isValidManifestEntry(entry)) {
+        return err$1(
+          manifestMalformed({
+            message: "ShaderRegistry: manifest entry missing required fields",
+            hint: "every entry needs {hash, wgsl, glsl, bindings} per @forgeax/engine-types.ManifestEntry",
+            reason: `bad entry: ${JSON.stringify(entry)}`
+          })
+        );
+      }
+      validatedEntries.push(entry);
+    }
+    const parsedSlim = parsed;
+    const validatedMaterialShaderEntries = [];
+    if (Array.isArray(parsedSlim.materialShaders)) {
+      for (const ms of parsedSlim.materialShaders) {
+        if (!isValidMaterialShaderManifestEntry(ms)) {
+          return err$1(
+            manifestMalformed({
+              message: "ShaderRegistry: manifest material shader entry missing required fields",
+              hint: "every material shader entry needs {identifier, sourcePath, composedWgsl, paramSchema, variants}",
+              reason: `bad material shader entry: ${JSON.stringify(ms)}`
+            })
+          );
+        }
+        validatedMaterialShaderEntries.push(ms);
+      }
+    }
+    this.#entries.clear();
+    for (const entry of validatedEntries) {
+      this.#entries.set(entry.hash, entry);
+    }
+    this.#materialShaderManifestEntries.length = 0;
+    this.#materialShaderManifestEntries.push(...validatedMaterialShaderEntries);
+    this.#manifestLoaded = true;
+    return ok$1(void 0);
+  }
+  /**
+   * Iterate every `ManifestEntry` populated by the most recent successful
+   * `loadManifest()` call. Order matches the manifest JSON `entries` array
+   * (insertion order; charter P2 structured-over-prose: AI users walk this
+   * to discover engine-shipped entries by content marker without
+   * re-fetching the manifest).
+   *
+   * Returns an empty iterator when no manifest has been loaded yet
+   * (charter P3 explicit failure: the empty case is not an error — the
+   * absent SSOT is the absent contract).
+   */
+  entries() {
+    return this.#entries.values();
+  }
+  /**
+   * Looks up a hash and forwards to `device.createShaderModule` (creates lazily
+   * on first hit, then caches).
+   *
+   * Error paths:
+   * - hash miss → `Result.err(ShaderError.shader-not-found)`
+   * - device.createShaderModule failed → `Result.err(RhiError)` passes through
+   *   (it is **not** wrapped as a ShaderError).
+   *
+   * Sync shape: on cache miss, the underlying `device.createShaderModule` is
+   * called synchronously; the caller is responsible for handling the async
+   * real path at the device-wrapper layer (e.g. the engine pre-compiles
+   * during `loadManifest`).
+   */
+  get(hash) {
+    const cachedModule = this.#moduleCache.get(hash);
+    if (cachedModule !== void 0) {
+      return ok$1(cachedModule);
+    }
+    const entry = this.#entries.get(hash);
+    if (entry === void 0) {
+      return err$1(
+        shaderNotFound({
+          hash,
+          hint: "verify manifest.json contains the expected hash; rerun build to regenerate manifest"
+        })
+      );
+    }
+    const result = this.#device.createShaderModule({ code: entry.wgsl, label: hash });
+    if (!result.ok) {
+      return result;
+    }
+    this.#moduleCache.set(hash, result.value);
+    return result;
+  }
+  // ─── MaterialShader registry surface ───────────────────────────────────────
+  // (feat-20260523-shader-template-instance-split M5 / T05 — plan-strategy
+  // D-DefaultStandardPbr-Identifier).
+  //
+  // Two-tier identifier namespace:
+  //   - `forgeax::*`  — engine-shipped reserved prefix; the host wires
+  //     `forgeax::default-standard-pbr` at engine boot from the
+  //     vite-plugin-shader manifest's `materialShaders[]` row + the
+  //     `default-standard-pbr.schema.json` SSOT (M5 / T08 + M6).
+  //   - any other identifier — user-side custom material shader, registered
+  //     after asset import.
+  //
+  // The registry is the runtime SSOT consumed by:
+  //   - `parseAssetPayload`'s `'::' two-way dispatch` (M4 / T01) — the path
+  //     branch validates against `paramSchema` and feeds `MaterialSnapshot.
+  //     materialShaderId` (M4 / T05).
+  //   - `render-system-record`'s pipeline cache key (M4 / T06) — same
+  //     identifier feeds the per-pipeline `(materialShaderId, stateHash)` key.
+  /**
+   * Register a material shader entry under a stable identifier.
+   *
+   * **Throws** on:
+   *   - duplicate registration of the same identifier (programmer error per
+   *     AGENTS.md "explicit registration" + Inspector "fail-fast no overwrite"
+   *     pattern; charter P3 explicit failure on misuse).
+   *
+   * Successful path returns void — the registry mutates in-place. Use
+   * {@link findMaterialArtifact} to read back.
+   *
+   * Identifier conventions (charter F1 / plan-strategy §8 §2):
+   *   - `forgeax::<kebab-case>` — engine-shipped reserved prefix; the host
+   *     registers `forgeax::default-standard-pbr` at boot.
+   *   - `<package>::<id>` or `<guid>` — user-side custom shaders.
+   *
+   * @example
+   * ```ts
+   * const registry = new ShaderRegistry({ device, manifestUrl });
+   * registry.installMaterialArtifact('forgeax::default-standard-pbr', {
+   *   source: composedWgsl,
+   *   paramSchema: defaultStandardPbrSchema,
+   * });
+   * ```
+   */
+  installMaterialArtifact(identifier, entry) {
+    if (this.#materialShaders.has(identifier)) {
+      throw new Error(
+        `ShaderRegistry: material shader identifier '${identifier}' already registered; same-name re-register is forbidden (AGENTS.md "explicit registration" + Inspector "fail-fast no overwrite" pattern). Use findMaterialArtifact to read back the existing entry.`
+      );
+    }
+    const paramSchemaProjection = this.#paramSchemaProjectionOwner.admit({
+      ownerId: identifier,
+      revision: 1,
+      schema: entry.paramSchema
+    });
+    if (!identifier.startsWith(FORGEAX_RESERVED_PATH_PREFIX)) {
+      const undeclared = findUndeclaredSampledTextures(entry.source, paramSchemaProjection.schema);
+      if (undeclared.length > 0) {
+        throw new Error(
+          `ShaderRegistry: material shader '${identifier}' samples texture(s) [${undeclared.join(", ")}] in its WGSL but its paramSchema does not declare them as texture entries. Add { name: '${undeclared[0]}', type: 'texture2d' } (and any others listed) to the paramSchema, or the engine would silently bind the default white texture (charter P3 explicit failure; see docs/handover/2026-06-19-blending-transparency-regression-bisect.md).`
+        );
+      }
+    }
+    this.#materialShaders.set(
+      identifier,
+      Object.freeze({
+        source: entry.source,
+        paramSchema: paramSchemaProjection.schema,
+        paramSchemaProjection
+      })
+    );
+  }
+  /**
+   * Lookup a previously-registered material shader entry by identifier.
+   *
+   * Returns `Result.ok(entry)` on hit, `Result.err(material-shader-not-found)`
+   * on miss. The `Result` shape mirrors `get(hash)` for consistent
+   * abstraction across the runtime registry surface (charter P4).
+   *
+   * @example
+   * ```ts
+   * const r = registry.findMaterialArtifact('forgeax::default-standard-pbr');
+   * if (!r.ok) return handleError(r.error);
+   * const { source, paramSchema } = r.value;
+   * ```
+   */
+  findMaterialArtifact(identifier) {
+    const entry = this.#materialShaders.get(identifier);
+    if (entry === void 0) {
+      return err$1(
+        materialShaderNotFound({
+          identifier,
+          expected: Array.from(this.#materialShaders.keys()),
+          hint: `register the shader via ShaderRegistry.installMaterialArtifact('${identifier}', ...) at engine boot, or grep '${FORGEAX_RESERVED_PATH_PREFIX}' to enumerate engine-shipped reserved identifiers`
+        })
+      );
+    }
+    return ok$1(entry);
+  }
+  /**
+   * Iterate every registered material shader identifier in registration
+   * order (charter F1 grep gate: `for (const id of registry.materialShaderIdentifiers())`
+   * lists every `forgeax::*` + user shader without a private-field reach-in).
+   */
+  materialShaderIdentifiers() {
+    return this.#materialShaders.keys();
+  }
+  /** Runtime diagnostic counters for the immutable ParamSchema owner. */
+  paramSchemaProjectionStats() {
+    return this.#paramSchemaProjectionOwner.stats();
+  }
+  /**
+   * Iterate every MaterialShaderManifestEntry parsed from manifest.json's
+   * `materialShaders[]` field during `loadManifest()`.
+   *
+   * feat-20260526-pbr-uniform-fallback-no-storage-buffer M3 / w12:
+   * createRenderer variant resolution consumes this list to select the
+   * correct variant (by `caps.storageBuffer`) and register the resolved
+   * WGSL via `installMaterialArtifact`.
+   *
+   * Returns an empty iterator when no manifest has been loaded yet or
+   * the manifest lacks `materialShaders` (backward-compatible).
+   */
+  materialShaderManifestEntries() {
+    return this.#materialShaderManifestEntries.values();
+  }
+};
+function isValidManifestEntry(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  if (typeof v.hash !== "string") return false;
+  if (typeof v.wgsl !== "string") return false;
+  if (v.glsl !== void 0 && v.glsl !== null && typeof v.glsl !== "string") return false;
+  if (typeof v.bindings !== "string") return false;
+  return true;
+}
+function isValidMaterialShaderManifestEntry(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  if (typeof v.identifier !== "string") return false;
+  if (typeof v.sourcePath !== "string") return false;
+  if (typeof v.composedWgsl !== "string") return false;
+  if (typeof v.paramSchema !== "string") return false;
+  if (!Array.isArray(v.variants)) return false;
+  if (!v.variants.every(isValidMaterialShaderManifestVariant)) return false;
+  return v.uvSetCount === void 0 || typeof v.uvSetCount === "number";
+}
+function isValidMaterialShaderManifestVariant(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  if (typeof v.definesKey !== "string") return false;
+  if (typeof v.composedWgsl !== "string") return false;
+  if (typeof v.defines !== "object" || v.defines === null || Array.isArray(v.defines)) {
+    return false;
+  }
+  return Object.values(v.defines).every((define) => typeof define === "boolean");
+}
+
+// src/types.ts
+function findVariantByKey(entry, definesKey) {
+  return entry.variants.find((v) => v.definesKey === definesKey);
+}
+
+// src/tonemap.ts
+var TONEMAP_SHADER_MODE = {
+  none: 0,
+  reinhardExtended: 1,
+  linear: 2,
+  cineon: 3,
+  acesFilmic: 4,
+  agx: 5,
+  neutral: 6,
+  reinhard: 7
+};
+
+// src/index.ts
+var BUILTIN_MATERIAL_MODULES = {
+  standard: "forgeax_material::standard",
+  unlit: "forgeax_material::unlit",
+  sprite: "forgeax_material::sprite"
+};
+var ENGINE_MATERIAL_MODULES = [
+  "forgeax::default-standard-pbr",
+  "forgeax::pbr-skin",
+  "forgeax::default-standard-pbr-skin",
+  "forgeax::default-unlit",
+  "forgeax::default-shadow-caster",
+  "forgeax::sprite",
+  "forgeax::sprite-lit",
+  "forgeax::msdf-text",
+  BUILTIN_MATERIAL_MODULES.standard,
+  BUILTIN_MATERIAL_MODULES.unlit,
+  BUILTIN_MATERIAL_MODULES.sprite,
+  "forgeax_material::sprite-lit"
+];
+function isEngineMaterialModule(module) {
+  return ENGINE_MATERIAL_MODULES.includes(module);
+}
+function isEngineMaterial(material) {
+  const passes = material.passes ?? [];
+  return passes.length > 0 && passes.every((pass) => isEngineMaterialModule(pass.program.module));
+}
+var BUILTIN_PARAMETERS = {
+  standard: [
+    { name: "baseColor", type: "color" },
+    { name: "metallic", type: "f32" },
+    { name: "roughness", type: "f32" },
+    { name: "alphaCutoff", type: "f32", optional: true }
+  ],
+  unlit: [{ name: "baseColor", type: "color" }],
+  sprite: [{ name: "colorTint", type: "vec4", colorSpace: "srgb" }]
+};
+var BUILTIN_VALUES = {
+  standard: {
+    baseColor: [1, 1, 1, 1],
+    metallic: 0,
+    roughness: 0.5,
+    alphaCutoff: STANDARD_PBR_ALPHA_CUTOFF_DEFAULT
+  },
+  unlit: { baseColor: [1, 1, 1, 1] },
+  sprite: { colorTint: [1, 1, 1, 1] }
+};
+function createBuiltinMaterialAsset(kind) {
+  return {
+    kind: "material",
+    passes: [{ name: "forward", program: { module: BUILTIN_MATERIAL_MODULES[kind] } }],
+    parameters: BUILTIN_PARAMETERS[kind],
+    values: BUILTIN_VALUES[kind]
+  };
+}
+var TONEMAP_LUMINANCE_EPSILON = 1e-5;
+
+export { BUILTIN_MATERIAL_MODULES, DEFAULT_MSDF_TEXT_PARAM_SCHEMA, DEFAULT_SPRITE_PARAM_SCHEMA, DEFAULT_STANDARD_PBR_PARAM_SCHEMA, DEFAULT_UNLIT_PARAM_SCHEMA, ENGINE_MATERIAL_MODULES, FORGEAX_RESERVED_PATH_PREFIX, MaterialArtifactRegistry, STANDARD_PBR_ALPHA_CUTOFF_DEFAULT, ShaderRegistry as ShaderCatalog, ShaderError, ShaderRegistry, TONEMAP_LUMINANCE_EPSILON, TONEMAP_SHADER_MODE, createBuiltinMaterialAsset, findVariantByKey, isEngineMaterial, isEngineMaterialModule, isMaterialShaderArtifact, manifestMalformed, materialShaderNotFound, registerDefaultSpriteLit, registerDefaultStandardPbrSkin, shaderNotFound };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map