@forgeax/engine-assets-runtime 0.1.4 → 0.1.6

package/src/registry/validate-material.ts

@@ -0,0 +1,386 @@
+// @forgeax/engine-assets-runtime -- material validation collaboration module (feat-20260705-runtime-tier2-decomposition M1 / w5, D-4). Free functions taking the AssetRegistry instance as first param; extracted from the class body, logic byte-preserved.
+
+import type { CookedMaterialRecord } from '@forgeax/engine-pack';
+import {
+  AssetError,
+  createMaterialError,
+  type MaterialAsset,
+  type MaterialError,
+  type MaterialParameter,
+} from '@forgeax/engine-types';
+import type { AssetRegistry } from '../asset-registry';
+
+/**
+ * Validate a MaterialAsset's passes[] against the ShaderRegistry's
+ * paramSchema (union semantics: all declared params across all passes
+ * must be satisfiable from values).
+ *
+ * - Empty / undefined passes[] → error
+ * - Each pass's shader must exist in ShaderRegistry
+ * - Union of all pass paramSchemas: params without `default` must
+ *   appear in values with matching type
+ * - Extra keys in values are silently ignored (D-5)
+ *
+ * @returns AssetError on failure, null on success
+ */
+export function validateMaterialPasses(
+  registry: AssetRegistry,
+  asset: MaterialAsset,
+): AssetError | null {
+  const passes = asset.passes;
+  // undefined passes is valid (material inherits from parent at resolve time);
+  // only explicit empty passes[] is an error.
+  if (passes === undefined || passes.length === 0) {
+    if (passes !== undefined && passes.length === 0) {
+      return new AssetError({
+        code: 'asset-invalid-value',
+        expected: 'MaterialAsset with at least one pass',
+        hint: 'add at least one pass descriptor to passes[] before register',
+        detail: { passCount: 0 },
+      });
+    }
+    // passes undefined: skip validation (inherits from parent later)
+    return null;
+  }
+
+  const allSchemas: MaterialParameter[] = [...(asset.parameters ?? [])];
+  for (let passIndex = 0; passIndex < passes.length; passIndex++) {
+    const pass = passes[passIndex];
+    if (pass === undefined) continue;
+    if (pass.program.module.length === 0) {
+      return new AssetError({
+        code: 'asset-invalid-value',
+        expected: 'pass.program.module to be a non-empty module identifier',
+        hint: `pass[${passIndex}] has an empty program.module`,
+      });
+    }
+  }
+
+  // Deduplicate by name (first occurrence wins)
+  const seen = new Set<string>();
+  const unionSchema: MaterialParameter[] = [];
+  for (const entry of allSchemas) {
+    if (!seen.has(entry.name)) {
+      seen.add(entry.name);
+      unionSchema.push(entry);
+    }
+  }
+
+  const values: Record<string, unknown> = (asset.values as Record<string, unknown>) ?? {};
+
+  // feat-20260613-material-paramschema-driven-binding M3 / w16 (D-2):
+  // derive(schema) is the SSOT for which schema fields are textures vs
+  // samplers vs numeric. The register-time three-layer validation (extra-
+  // key / type-mismatch / missing-required) categorizes fields via
+  // derive output instead of a hardcoded literal type list. Texture
+  // and sampler fields are always optional at register time (the
+  // resource handles may not be available yet — D-5 graceful path),
+  // so derive-derived membership decides the skip set without keeping
+  // a parallel literal table.
+  const missingParams: string[] = [];
+  for (const entry of unionSchema) {
+    const value = values[entry.name];
+    if (value === undefined) {
+      if (entry.default !== undefined || entry.optional || entry.type === 'texture') {
+        continue;
+      }
+      missingParams.push(entry.name);
+      continue;
+    }
+    if (value === null && entry.optional) continue;
+    // Type-check supplied values
+    const typeOk = validateParamType(registry, entry.name, entry.type, value);
+    if (!typeOk) {
+      return new AssetError({
+        code: 'asset-invalid-value',
+        expected: `values.${entry.name} to be of type ${entry.type}`,
+        hint: `values['${entry.name}'] has type ${typeof value} but paramSchema declares ${entry.type}`,
+        detail: { paramName: entry.name, expectedType: entry.type, got: typeof value },
+      });
+    }
+  }
+
+  if (missingParams.length > 0) {
+    return new AssetError({
+      code: 'asset-invalid-value',
+      expected: `values to contain keys: ${missingParams.join(', ')}`,
+      hint: `missing required params: ${missingParams.join(', ')}`,
+      detail: { missingParams },
+    });
+  }
+
+  return null;
+}
+
+export interface MaterialEffectiveRootIdentity {
+  readonly guid: string;
+  readonly layoutIdentity: string;
+}
+
+export function validateMaterialCookIdentity(
+  record: Pick<CookedMaterialRecord, 'guid' | 'receipt'>,
+  root: MaterialEffectiveRootIdentity,
+): MaterialError | null {
+  const actual = record.receipt.layoutIdentity;
+  if (
+    actual !== root.layoutIdentity ||
+    (record.receipt as { readonly derivedInterface?: { readonly layoutIdentity?: string } })
+      .derivedInterface?.layoutIdentity !== root.layoutIdentity
+  ) {
+    return createMaterialError('material-derived-interface-mismatch', {
+      code: 'material-derived-interface-mismatch',
+      stage: 'extract',
+      material: record.guid,
+      layoutIdentity: root.layoutIdentity,
+      expectedIdentity: root.layoutIdentity,
+      actualIdentity: actual,
+      action: 'recook',
+    });
+  }
+  return null;
+}
+
+/**
+ * Sprite 9-slice values fail-fast validation
+ * (feat-20260527-sprite-nineslice M2 / w8, plan-strategy §D-1 + AC-08).
+ *
+ * Fires when:
+ *  - asset.kind === 'material'
+ *  - first pass shader === 'forgeax::sprite'
+ *  - values.slices is present
+ *
+ * Six fail-fast branches (1:1 with w4 test):
+ *   (1) any component is negative
+ *   (2) slices.x + slices.z >= region.zw[0]   (X-axis overlap)
+ *   (3) slices.y + slices.w >= region.zw[1]   (Y-axis overlap)
+ *   (4) any component is NaN
+ *   (5) any component is Infinity
+ *   (6) length !== 4
+ *
+ * Reuses the existing 'asset-invalid-value' member of the closed
+ * `AssetErrorCode` 13-member union (no new code added per
+ * AGENTS.md §Error model). The `.expected` literal mirrors the AI-User
+ * Charter §3 string; `.hint` inlines the offending sum + the relevant
+ * `region.zw` numeral so AI users can copy-paste the prompt straight
+ * back into the IDE for self-recovery (plan-strategy §R-4).
+ *
+ * @returns AssetError on failure, null on success.
+ */
+export function validateSpriteSlices(
+  _registry: AssetRegistry,
+  asset: MaterialAsset,
+): AssetError | null {
+  const passes = asset.passes;
+  if (passes === undefined || passes.length === 0) return null;
+  const firstPass = passes[0];
+  if (firstPass === undefined || firstPass.program.module !== 'forgeax_material::sprite')
+    return null;
+  const pv = (asset.values ?? {}) as Record<string, unknown>;
+  const slicesRaw = pv.slices;
+  // Field absent — caller relies on paramSchema default [0, 0, 0, 0]; nothing to check.
+  if (slicesRaw === undefined) return null;
+  const expected =
+    'values.slices: [number, number, number, number] with 0 ≤ left + right < region.zw[0] and 0 ≤ top + bottom < region.zw[1]';
+  if (!Array.isArray(slicesRaw)) {
+    return new AssetError({
+      code: 'asset-invalid-value',
+      expected,
+      hint: `values.slices is not an array (got ${typeof slicesRaw}); must be a 4-tuple [left, top, right, bottom]`,
+      detail: { paramName: 'slices', got: typeof slicesRaw },
+    });
+  }
+  // (6) length check
+  if (slicesRaw.length !== 4) {
+    return new AssetError({
+      code: 'asset-invalid-value',
+      expected,
+      hint: `values.slices length is ${slicesRaw.length}; must be 4 ([left, top, right, bottom])`,
+      detail: { paramName: 'slices', got: slicesRaw.length },
+    });
+  }
+  const slices = slicesRaw as readonly unknown[];
+  // Type check each component first.
+  for (let i = 0; i < 4; i++) {
+    if (typeof slices[i] !== 'number') {
+      return new AssetError({
+        code: 'asset-invalid-value',
+        expected,
+        hint: `values.slices[${i}] is not a number (got ${typeof slices[i]})`,
+        detail: { paramName: 'slices', got: typeof slices[i] },
+      });
+    }
+  }
+  const left = slices[0] as number;
+  const top = slices[1] as number;
+  const right = slices[2] as number;
+  const bottom = slices[3] as number;
+  // (4) NaN
+  for (let i = 0; i < 4; i++) {
+    if (Number.isNaN(slices[i] as number)) {
+      return new AssetError({
+        code: 'asset-invalid-value',
+        expected,
+        hint: `values.slices[${i}] is NaN; all four components must be finite non-negative numbers`,
+        detail: { paramName: 'slices', got: 'NaN' },
+      });
+    }
+  }
+  // (5) Infinity
+  for (let i = 0; i < 4; i++) {
+    if (!Number.isFinite(slices[i] as number)) {
+      return new AssetError({
+        code: 'asset-invalid-value',
+        expected,
+        hint: `values.slices[${i}] is Infinity; all four components must be finite non-negative numbers`,
+        detail: { paramName: 'slices', got: 'Infinity' },
+      });
+    }
+  }
+  // (1) negative — D-3 sentinel uses negative .w for tile mode but only
+  // after extract; at register-time the user-supplied tuple must be all
+  // non-negative (the engine encodes the sign downstream).
+  for (let i = 0; i < 4; i++) {
+    if ((slices[i] as number) < 0) {
+      return new AssetError({
+        code: 'asset-invalid-value',
+        expected,
+        hint: `values.slices[${i}] = ${slices[i]}; all four components must be non-negative`,
+        detail: { paramName: 'slices', got: slices[i] as number },
+      });
+    }
+  }
+  // (2)/(3) overlap with region. region default is [0, 0, 1, 1];
+  // user override comes via values.region (vec4).
+  const regionRaw = pv.region;
+  let regionZ = 1;
+  let regionW = 1;
+  if (Array.isArray(regionRaw) && regionRaw.length >= 4) {
+    const rz = regionRaw[2];
+    const rw = regionRaw[3];
+    if (typeof rz === 'number') regionZ = rz;
+    if (typeof rw === 'number') regionW = rw;
+  }
+  const sumX = left + right;
+  if (sumX >= regionZ) {
+    return new AssetError({
+      code: 'asset-invalid-value',
+      expected,
+      hint: `received slices=[${left}, ${top}, ${right}, ${bottom}]; left + right = ${sumX} ≥ ${regionZ} (region.z)`,
+      detail: { paramName: 'slices', got: sumX },
+    });
+  }
+  const sumY = top + bottom;
+  if (sumY >= regionW) {
+    return new AssetError({
+      code: 'asset-invalid-value',
+      expected,
+      hint: `received slices=[${left}, ${top}, ${right}, ${bottom}]; top + bottom = ${sumY} ≥ ${regionW} (region.w)`,
+      detail: { paramName: 'slices', got: sumY },
+    });
+  }
+  return null;
+}
+
+export function validateParamType(
+  _registry: AssetRegistry,
+  _name: string,
+  type: string,
+  value: unknown,
+): boolean {
+  switch (type) {
+    case 'f32':
+    case 'i32':
+    case 'u32':
+      return typeof value === 'number';
+    case 'vec2':
+      return Array.isArray(value) && value.length >= 2 && value.every((v) => typeof v === 'number');
+    case 'vec3':
+      return Array.isArray(value) && value.length >= 3 && value.every((v) => typeof v === 'number');
+    case 'vec4':
+      return Array.isArray(value) && value.length >= 4 && value.every((v) => typeof v === 'number');
+    case 'color':
+      return (
+        Array.isArray(value) &&
+        (value.length === 3 || value.length === 4) &&
+        value.every((v) => typeof v === 'number')
+      );
+    case 'texture':
+      // A cooked pack may keep an asset GUID as the compact texture
+      // shorthand. The render material resolver expands that reference at
+      // the resource boundary; rejecting it here makes authored packs fail
+      // before the same value can reach the resolver.
+      return (
+        typeof value === 'string' ||
+        (typeof value === 'object' && value !== null && !Array.isArray(value))
+      );
+    case 'bool':
+      return typeof value === 'boolean';
+    default:
+      return false;
+  }
+}
+
+/**
+ * feat-20260527-sprite-nineslice M4 / w18 (D-9): register-time soft-warn
+ * for sliceMode=1 (tile) bound to a sampler whose addressMode is not
+ * 'repeat'. Bumps `nineslice.tile-needs-repeat-sampler` once per offending
+ * catalogue call. Never throws -- the counter is the sole AI-user-facing
+ * signal (charter P3 machine-readable; AC-08 closed, never extends
+ * AssetErrorCode).
+ *
+ * feat-20260614 M8 (D-19): `values.sampler` is now an embedded GUID
+ * string (dash-form), resolved against the catalogue rather than a handle.
+ */
+export function detectTileNeedsRepeatSampler(registry: AssetRegistry, asset: MaterialAsset): void {
+  if (registry.metrics === null) return;
+  const passes = asset.passes;
+  if (passes === undefined || passes.length === 0) return;
+  const firstPass = passes[0];
+  if (
+    firstPass === undefined ||
+    (firstPass.program.module !== 'forgeax_material::sprite' &&
+      firstPass.program.module !== 'forgeax::sprite')
+  )
+    return;
+  const pv = (asset.values ?? {}) as Record<string, unknown>;
+  const slicesAndMode = pv.slicesAndMode;
+  const encodedTile =
+    Array.isArray(slicesAndMode) && typeof slicesAndMode[3] === 'number'
+      ? slicesAndMode[3] < 0
+      : false;
+  const legacyTile = typeof pv.sliceMode === 'number' && pv.sliceMode === 1;
+  if (!encodedTile && !legacyTile) return;
+  const samplerGuid = typeof pv.sampler === 'string' ? pv.sampler : undefined;
+  if (samplerGuid === undefined) return;
+  const samplerEnvelope = registry.assetCatalog.get(samplerGuid.toLowerCase());
+  if (samplerEnvelope === undefined || samplerEnvelope.kind !== 'sampler') return;
+  const samplerAsset = samplerEnvelope.payload;
+  if (samplerAsset.kind !== 'sampler') return;
+  const u = samplerAsset.addressModeU;
+  const v = samplerAsset.addressModeV;
+  if (u !== 'repeat' || v !== 'repeat') {
+    registry.metrics.increment('nineslice.tile-needs-repeat-sampler');
+  }
+}
+
+/**
+ * feat-20260613-material-paramschema-driven-binding M4 / w23 (D-5 graceful):
+ * Return the texture-field name set for the given material-shader id,
+ * derived from the registered shader's paramSchema via `derive(paramSchema)
+ * .textureFieldNames`. Returns `undefined` when the shader is not yet
+ * registered (cross-worktree shader-late-register, plan R-4).
+ *
+ * Used by `extractFrame` to know which values fields the shader
+ * declares as texture handles; the extract layer validates handle-vs-
+ * scalar typing and drops misclassified slots so the record stage's
+ * MISSING_TEXTURE_HANDLE fallback can take over (white default texture)
+ * rather than letting a stray handle reach `device.createBindGroup`.
+ */
+export function materialShaderTextureFieldNames(
+  registry: AssetRegistry,
+  shaderId: string,
+): ReadonlySet<string> | undefined {
+  const lookup = registry.shaderRegistry.findMaterialArtifact(shaderId);
+  if (!lookup.ok) return undefined;
+  return lookup.value.paramSchemaProjection.derivedInterface.textureFieldNames;
+}

package/src/resolve-asset-handle.ts

@@ -0,0 +1,147 @@
+// M8 w59 (round 5 D-18 atomic): two-tier resolution + material-walk over
+// world.sharedRefs.
+//
+// D-15 two-tier asset resolution: slots in [1, BUILTIN_BASE) are builtins
+// (process-static, resolve through BuiltinAssetRegistry.resolve, never
+// reference-counted); slots >= BUILTIN_BASE are user-tier (resolve through
+// world.sharedRefs.resolve). Resolution is entirely ECS/render-side -- it
+// never goes through AssetRegistry (human-inputs implement-architecture-
+// correction 2026-06-16T12:35:07Z: AssetRegistry has NO handle concept).
+//
+// AI-user surface: `resolveAssetHandle(world, handle)` is the single entry
+// point for handle-to-payload resolution; `walkMaterialPassesOverSharedRefs`
+// is the material parent-chain walk used by the render extract stage. Charter
+// F1 single-entry indexability -- one import, one call, no dual-path leak.
+
+import type { SharedRefStaleError, UniqueRefStaleError, World } from '@forgeax/engine-ecs';
+import type { AssetGuid } from '@forgeax/engine-pack/guid';
+import { err, ok, type Result } from '@forgeax/engine-rhi';
+import type {
+  Asset,
+  AssetError as AssetErrorType,
+  Handle,
+  MaterialAsset,
+  MaterialError,
+  MaterialPass,
+} from '@forgeax/engine-types';
+import {
+  ASSET_ERROR_HINTS,
+  AssetError,
+  BUILTIN_BASE,
+  handleSlot,
+  materialGuidText,
+  resolveMaterialAsset,
+} from '@forgeax/engine-types';
+import { BuiltinAssetRegistry } from './builtin-asset-registry';
+
+/**
+ * Resolve a handle to its asset payload with two-tier slot-range dispatch.
+ *
+ *   slot <  BUILTIN_BASE -> BuiltinAssetRegistry.resolve(handle) (process-static)
+ *   slot >= BUILTIN_BASE -> world.sharedRefs.resolve(handle)     (user-tier RC)
+ *
+ * Callers must specify the expected asset type explicitly:
+ * `resolveAssetHandle<MeshAsset>(world, handle)`. The type parameter is an
+ * assertion -- the runtime dispatch returns the correct payload based on slot
+ * range; the type parameter mirrors the caller's expectation.
+ *
+ * @param world - The World owning the per-World SharedRefStore (user-tier).
+ * @param handle - The branded handle to resolve.
+ * @returns `Result.ok(payload)` on hit, `Result.err(AssetError)` on miss.
+ */
+export function resolveAssetHandle<T extends Asset>(
+  world: World,
+  handle: Handle<string, 'shared'>,
+): Result<T, AssetErrorType | SharedRefStaleError | UniqueRefStaleError> {
+  const slot = handleSlot(handle);
+  if (slot < BUILTIN_BASE) {
+    const builtin = BuiltinAssetRegistry.resolve(handle);
+    if (builtin !== null) return ok(builtin as unknown as T);
+    return err(
+      new AssetError({
+        code: 'asset-not-found',
+        expected: `builtin slot ${slot} present in BuiltinAssetRegistry`,
+        hint: ASSET_ERROR_HINTS['asset-not-found'],
+      }),
+    );
+  }
+  const res = world.sharedRefs.resolve<string, T>(handle);
+  if (res.ok) return ok(res.value);
+  // Forward the closed error code transparently. Checking the discriminant,
+  // rather than constructor identity, preserves the structured stale detail
+  // when a browser bundles the bridge and its World through different module
+  // instances.
+  switch (res.error.code) {
+    case 'shared-ref-stale':
+      return err(res.error);
+    case 'shared-ref-released':
+    case 'builtin-slot-not-owned':
+      break;
+  }
+  return err(
+    new AssetError({
+      code: 'asset-not-found',
+      expected: `user-tier slot ${slot} present in world.sharedRefs`,
+      hint: ASSET_ERROR_HINTS['asset-not-found'],
+    }),
+  );
+}
+
+/**
+ * Walk a MaterialAsset parent chain to produce the inherited passes +
+ * shallow-merged values (W-1..W-7 semantics). feat-20260614 M8 (D-19):
+ * the starting material is resolved from a column `handle` via
+ * {@link resolveAssetHandle} (builtin / user-tier world.sharedRefs); each
+ * ancestor `material.parent` is an embedded GUID (AssetGuid) resolved through
+ * the AssetRegistry catalogue ({@link AssetRegistry.lookup}). The registry
+ * holds no handles -- it is the GUID->payload SSOT for parent resolution.
+ *
+ * Zero-cache (AC-04): every call builds the same table-shaped input and delegates
+ * inheritance semantics to the MaterialAsset resolver in `@forgeax/engine-types`.
+ * Compiler and runtime therefore share root-contract ownership and child-value
+ * override semantics instead of maintaining two subtly different walks.
+ */
+export function walkMaterialPassesOverSharedRefs(
+  world: World,
+  handle: Handle<'MaterialAsset', 'shared'>,
+  registry: { lookup(guid: AssetGuid | string): Asset | undefined },
+): Result<
+  {
+    passes: MaterialPass[];
+    parameters: MaterialAsset['parameters'];
+    values: NonNullable<MaterialAsset['values']>;
+    colorSpace: MaterialAsset['colorSpace'];
+  },
+  AssetErrorType | MaterialError | SharedRefStaleError | UniqueRefStaleError
+> {
+  // Resolve the root material payload from its column handle.
+  const rootRes = resolveAssetHandle<MaterialAsset>(
+    world,
+    handle as unknown as Handle<string, 'shared'>,
+  );
+
+  const rootLabel = `handle-${handleSlot(handle)}`;
+  if (!rootRes.ok) return err(rootRes.error);
+
+  const table: Record<string, MaterialAsset> = {};
+  const visited = new Set<string>();
+  const collect = (label: string, material: MaterialAsset): void => {
+    if (visited.has(label)) return;
+    visited.add(label);
+    table[label] = material;
+    if (material.parent === undefined) return;
+    const parentId = materialGuidText(material.parent);
+    const parent = registry.lookup(material.parent);
+    if (parent?.kind === 'material') collect(parentId, parent);
+  };
+  collect(rootLabel, rootRes.value);
+
+  const resolved = resolveMaterialAsset(rootLabel, table);
+  if (!resolved.ok) return err(resolved.error);
+  return ok({
+    passes: [...(resolved.value.asset.passes ?? [])],
+    parameters: resolved.value.asset.parameters ?? [],
+    values: { ...(resolved.value.asset.values ?? {}) },
+    colorSpace: resolved.value.asset.colorSpace,
+  });
+}

package/src/resolve-tileset-runtime.ts

@@ -0,0 +1,72 @@
+import type { World } from '@forgeax/engine-ecs';
+import type { Asset, Handle, Result, TextureAsset } from '@forgeax/engine-types';
+import { err, ok } from '@forgeax/engine-types';
+
+export type TilesetRuntimeErrorCode =
+  | 'tileset-atlas-not-found'
+  | 'tileset-atlas-stale'
+  | 'tileset-atlas-kind-mismatch';
+
+export interface TilesetRuntimeError {
+  readonly code: TilesetRuntimeErrorCode;
+  readonly expected: string;
+  readonly hint: string;
+  readonly detail: {
+    readonly guid: string;
+    readonly actualKind?: string;
+  };
+}
+
+export interface ResolvedTilesetRuntime {
+  readonly guid: string;
+  readonly payload: TextureAsset;
+  readonly handle: Handle<'TextureAsset', 'shared'>;
+}
+
+export type TilesetAtlasLookup = Asset | { readonly code: 'stale' } | undefined;
+
+/** Project one durable atlas GUID into the current World at the tilemap owner. */
+export function resolveTilesetRuntime(
+  world: World,
+  guid: string,
+  lookup: (guid: string) => TilesetAtlasLookup,
+): Result<ResolvedTilesetRuntime, TilesetRuntimeError> {
+  if (guid.length === 0) {
+    return err({
+      code: 'tileset-atlas-not-found',
+      expected: 'a non-empty durable atlas GUID',
+      hint: 'load the atlas payload before extracting the tilemap',
+      detail: { guid },
+    });
+  }
+  const payload = lookup(guid);
+  if (payload === undefined) {
+    return err({
+      code: 'tileset-atlas-not-found',
+      expected: `a loaded texture payload for atlas GUID ${guid}`,
+      hint: 'load or retain the atlas before extracting the tilemap',
+      detail: { guid },
+    });
+  }
+  if ('code' in payload) {
+    return err({
+      code: 'tileset-atlas-stale',
+      expected: `a current texture payload for atlas GUID ${guid}`,
+      hint: 'rebuild the stale atlas projection before extracting the tilemap',
+      detail: { guid },
+    });
+  }
+  if (payload.kind !== 'texture') {
+    return err({
+      code: 'tileset-atlas-kind-mismatch',
+      expected: 'a texture atlas payload',
+      hint: `replace atlas GUID ${guid} with a texture asset`,
+      detail: { guid, actualKind: payload.kind },
+    });
+  }
+  return ok({
+    guid,
+    payload,
+    handle: world.internSharedRef('TextureAsset', payload),
+  });
+}