@contractspec/lib.overlay-engine 3.7.6 → 3.7.7

package/README.md

@@ -1,85 +1,73 @@
 # @contractspec/lib.overlay-engine
 
-Website: https://contractspec.io/
-
-
-Runtime utilities for executing **OverlaySpecs** inside ContractSpec applications. The library tracks signed overlays, validates their safety guarantees, merges multi-scope overlays, and exposes React helpers to render personalized layouts without bespoke code.
-
-## Features
-
-- Type-safe OverlaySpec definitions that mirror the docs.
-- Cryptographic signing and verification (Ed25519, RSA-PSS).
-- Registry + validator that enforces policy boundaries.
-- Deterministic merge engine for tenant / role / user overlays.
-- Runtime helpers + React hooks for applying overlays to form/data view field definitions.
-
-## Usage
-
-```ts
-import {
-  OverlayEngine,
-  OverlayRegistry,
-  defineOverlay,
-  signOverlay,
-} from '@contractspec/lib.overlay-engine';
-
-const registry = new OverlayRegistry();
-const engine = new OverlayEngine({ registry });
-
-const overlay = defineOverlay({
-  overlayId: 'acme-order-form',
-  version: '1.0.0',
-  appliesTo: {
-    capability: 'billing.createOrder',
-    tenantId: 'acme',
-  },
-  modifications: [
-    { type: 'hideField', field: 'internalNotes' },
-    { type: 'renameLabel', field: 'customerReference', newLabel: 'PO Number' },
-  ],
-});
-
-const signed = await signOverlay(overlay, PRIVATE_KEY_PEM, { keyId: 'acme' });
-registry.register(signed);
-
-const result = engine.apply({
-  target: {
-    fields: baseFields,
-  },
-  context: { tenantId: 'acme', userId: 'u_123' },
-  capability: 'billing.createOrder',
-});
-```
-
-See `docs/tech/personalization/overlay-engine.md` for additional details.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+Website: https://contractspec.io
 
+**Runtime overlay engine for ContractSpec personalization and adaptive UI rendering.**
 
+## What It Provides
 
+- **Layer**: lib.
+- **Consumers**: personalization, example-shared-ui, bundles.
+- Related ContractSpec packages include `@contractspec/lib.contracts-spec`, `@contractspec/tool.bun`, `@contractspec/tool.typescript`.
+- Related ContractSpec packages include `@contractspec/lib.contracts-spec`, `@contractspec/tool.bun`, `@contractspec/tool.typescript`.
 
+## Installation
 
+`npm install @contractspec/lib.overlay-engine`
 
+or
 
+`bun add @contractspec/lib.overlay-engine`
 
+## Usage
 
+Import the root entrypoint from `@contractspec/lib.overlay-engine`, or choose a documented subpath when you only need one part of the package surface.
+
+## Architecture
+
+- `src/index.ts` is the root public barrel and package entrypoint.
+- `src/merger.ts` is part of the package's public or composition surface.
+- `src/react.ts` is part of the package's public or composition surface.
+- `src/registry.ts` is part of the package's public or composition surface.
+- `src/runtime.ts` is part of the package's public or composition surface.
+- `src/signer.ts` is part of the package's public or composition surface.
+- `src/spec.ts` is part of the package's public or composition surface.
+- `src/types.ts` is shared public type definitions.
+
+## Public Entry Points
+
+- Export `.` resolves through `./src/index.ts`.
+- Export `./merger` resolves through `./src/merger.ts`.
+- Export `./react` resolves through `./src/react.ts`.
+- Export `./registry` resolves through `./src/registry.ts`.
+- Export `./runtime` resolves through `./src/runtime.ts`.
+- Export `./signer` resolves through `./src/signer.ts`.
+- Export `./spec` resolves through `./src/spec.ts`.
+- Export `./types` resolves through `./src/types.ts`.
+- Export `./validator` resolves through `./src/validator.ts`.
+
+## Local Commands
+
+- `bun run dev` — contractspec-bun-build dev
+- `bun run build` — bun run prebuild && bun run build:bundle && bun run build:types
+- `bun run test` — bun test --pass-with-no-tests
+- `bun run lint` — bun lint:fix
+- `bun run lint:check` — biome check .
+- `bun run lint:fix` — biome check --write --unsafe --only=nursery/useSortedClasses . && biome check --write .
+- `bun run typecheck` — tsc --noEmit
+- `bun run publish:pkg` — bun publish --tolerate-republish --ignore-scripts --verbose
+- `bun run publish:pkg:canary` — bun publish:pkg --tag canary
+- `bun run clean` — rimraf dist .turbo
+- `bun run build:bundle` — contractspec-bun-build transpile
+- `bun run build:types` — contractspec-bun-build types
+- `bun run prebuild` — contractspec-bun-build prebuild
+
+## Recent Updates
+
+- Replace eslint+prettier by biomejs to optimize speed.
+
+## Notes
+
+- Overlay spec schema is a contract — changes are breaking for all consumers.
+- Signer must preserve cryptographic integrity; do not alter signing algorithm without migration.
+- Merger logic must be idempotent — applying the same overlay twice must produce identical results.

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-export * from './spec';
-export * from './types';
+export * from './merger';
 export * from './registry';
-export * from './validator';
 export * from './runtime';
-export * from './merger';
 export * from './signer';
+export * from './spec';
+export * from './types';
+export * from './validator';

package/dist/index.js

@@ -1,15 +1,127 @@
 // @bun
-// src/spec.ts
-var OVERLAY_SCOPE_ORDER = [
-  "tenantId",
-  "role",
-  "userId",
-  "device",
-  "tags"
-];
-function defineOverlay(spec) {
-  return spec;
+// src/merger.ts
+function applyOverlayModifications(target, overlays, options = {}) {
+  if (!overlays.length) {
+    return target;
+  }
+  const states = target.fields.map((field) => ({
+    key: field.key,
+    field: { ...field },
+    hidden: field.visible === false
+  }));
+  const fieldMap = new Map(states.map((state) => [state.key, state]));
+  let orderSequence = target.fields.map((field) => field.key);
+  const handleMissing = (field, overlayId) => {
+    if (options.strict) {
+      throw new Error(`Overlay "${overlayId}" referenced unknown field "${field}".`);
+    }
+  };
+  overlays.forEach((overlay) => {
+    overlay.modifications.forEach((modification) => {
+      switch (modification.type) {
+        case "hideField": {
+          const state = fieldMap.get(modification.field);
+          if (!state)
+            return handleMissing(modification.field, overlay.overlayId);
+          state.hidden = true;
+          state.field.visible = false;
+          break;
+        }
+        case "renameLabel": {
+          const state = fieldMap.get(modification.field);
+          if (!state)
+            return handleMissing(modification.field, overlay.overlayId);
+          state.field.label = modification.newLabel;
+          break;
+        }
+        case "setDefault": {
+          const state = fieldMap.get(modification.field);
+          if (!state)
+            return handleMissing(modification.field, overlay.overlayId);
+          state.field.defaultValue = modification.value;
+          break;
+        }
+        case "addHelpText": {
+          const state = fieldMap.get(modification.field);
+          if (!state)
+            return handleMissing(modification.field, overlay.overlayId);
+          state.field.helpText = modification.text;
+          break;
+        }
+        case "makeRequired": {
+          const state = fieldMap.get(modification.field);
+          if (!state)
+            return handleMissing(modification.field, overlay.overlayId);
+          state.field.required = modification.required ?? true;
+          break;
+        }
+        case "reorderFields": {
+          const { filtered, missing } = normalizeOrderList(modification.fields, fieldMap);
+          if (missing.length && options.strict) {
+            missing.forEach((field) => handleMissing(field, overlay.overlayId));
+          }
+          orderSequence = applyReorder(orderSequence, filtered);
+          break;
+        }
+        default:
+          break;
+      }
+    });
+  });
+  const visibleFields = [];
+  const seen = new Set;
+  orderSequence.forEach((key) => {
+    const state = fieldMap.get(key);
+    if (!state || state.hidden) {
+      return;
+    }
+    seen.add(key);
+    visibleFields.push(state.field);
+  });
+  states.forEach((state) => {
+    if (state.hidden || seen.has(state.key)) {
+      return;
+    }
+    visibleFields.push(state.field);
+  });
+  visibleFields.forEach((field, index) => {
+    field.order = index;
+    field.visible = true;
+  });
+  return {
+    ...target,
+    fields: visibleFields
+  };
 }
+function normalizeOrderList(fields, fieldMap) {
+  const filtered = [];
+  const missing = [];
+  const seen = new Set;
+  fields.forEach((field) => {
+    if (!field?.trim()) {
+      return;
+    }
+    if (!fieldMap.has(field)) {
+      missing.push(field);
+      return;
+    }
+    if (seen.has(field)) {
+      return;
+    }
+    seen.add(field);
+    filtered.push(field);
+  });
+  return { filtered, missing };
+}
+function applyReorder(sequence, orderedFields) {
+  if (!orderedFields.length) {
+    return sequence;
+  }
+  const orderedSet = new Set(orderedFields);
+  const remainder = sequence.filter((key) => !orderedSet.has(key));
+  return [...orderedFields, ...remainder];
+}
+
 // src/validator.ts
 var TARGET_KEYS = [
   "capability",
@@ -270,129 +382,6 @@ function matches(appliesTo, ctx) {
   return true;
 }
 
-// src/merger.ts
-function applyOverlayModifications(target, overlays, options = {}) {
-  if (!overlays.length) {
-    return target;
-  }
-  const states = target.fields.map((field) => ({
-    key: field.key,
-    field: { ...field },
-    hidden: field.visible === false
-  }));
-  const fieldMap = new Map(states.map((state) => [state.key, state]));
-  let orderSequence = target.fields.map((field) => field.key);
-  const handleMissing = (field, overlayId) => {
-    if (options.strict) {
-      throw new Error(`Overlay "${overlayId}" referenced unknown field "${field}".`);
-    }
-  };
-  overlays.forEach((overlay) => {
-    overlay.modifications.forEach((modification) => {
-      switch (modification.type) {
-        case "hideField": {
-          const state = fieldMap.get(modification.field);
-          if (!state)
-            return handleMissing(modification.field, overlay.overlayId);
-          state.hidden = true;
-          state.field.visible = false;
-          break;
-        }
-        case "renameLabel": {
-          const state = fieldMap.get(modification.field);
-          if (!state)
-            return handleMissing(modification.field, overlay.overlayId);
-          state.field.label = modification.newLabel;
-          break;
-        }
-        case "setDefault": {
-          const state = fieldMap.get(modification.field);
-          if (!state)
-            return handleMissing(modification.field, overlay.overlayId);
-          state.field.defaultValue = modification.value;
-          break;
-        }
-        case "addHelpText": {
-          const state = fieldMap.get(modification.field);
-          if (!state)
-            return handleMissing(modification.field, overlay.overlayId);
-          state.field.helpText = modification.text;
-          break;
-        }
-        case "makeRequired": {
-          const state = fieldMap.get(modification.field);
-          if (!state)
-            return handleMissing(modification.field, overlay.overlayId);
-          state.field.required = modification.required ?? true;
-          break;
-        }
-        case "reorderFields": {
-          const { filtered, missing } = normalizeOrderList(modification.fields, fieldMap);
-          if (missing.length && options.strict) {
-            missing.forEach((field) => handleMissing(field, overlay.overlayId));
-          }
-          orderSequence = applyReorder(orderSequence, filtered);
-          break;
-        }
-        default:
-          break;
-      }
-    });
-  });
-  const visibleFields = [];
-  const seen = new Set;
-  orderSequence.forEach((key) => {
-    const state = fieldMap.get(key);
-    if (!state || state.hidden) {
-      return;
-    }
-    seen.add(key);
-    visibleFields.push(state.field);
-  });
-  states.forEach((state) => {
-    if (state.hidden || seen.has(state.key)) {
-      return;
-    }
-    visibleFields.push(state.field);
-  });
-  visibleFields.forEach((field, index) => {
-    field.order = index;
-    field.visible = true;
-  });
-  return {
-    ...target,
-    fields: visibleFields
-  };
-}
-function normalizeOrderList(fields, fieldMap) {
-  const filtered = [];
-  const missing = [];
-  const seen = new Set;
-  fields.forEach((field) => {
-    if (!field?.trim()) {
-      return;
-    }
-    if (!fieldMap.has(field)) {
-      missing.push(field);
-      return;
-    }
-    if (seen.has(field)) {
-      return;
-    }
-    seen.add(field);
-    filtered.push(field);
-  });
-  return { filtered, missing };
-}
-function applyReorder(sequence, orderedFields) {
-  if (!orderedFields.length) {
-    return sequence;
-  }
-  const orderedSet = new Set(orderedFields);
-  const remainder = sequence.filter((key) => !orderedSet.has(key));
-  return [...orderedFields, ...remainder];
-}
-
 // src/runtime.ts
 class OverlayEngine {
   registry;
@@ -445,7 +434,6 @@ function extractContext(params) {
 }
 
 // src/signer.ts
-import stringify from "fast-json-stable-stringify";
 import {
   constants,
   createPrivateKey,
@@ -453,6 +441,7 @@ import {
   sign,
   verify
 } from "crypto";
+import stringify from "fast-json-stable-stringify";
 function signOverlay(spec, privateKey, options = {}) {
   const algorithm = options.algorithm ?? "ed25519";
   const keyObject = typeof privateKey === "string" || Buffer.isBuffer(privateKey) ? createPrivateKey(privateKey) : privateKey;
@@ -519,6 +508,18 @@ function toIso(value) {
   }
   return value.toISOString();
 }
+
+// src/spec.ts
+var OVERLAY_SCOPE_ORDER = [
+  "tenantId",
+  "role",
+  "userId",
+  "device",
+  "tags"
+];
+function defineOverlay(spec) {
+  return spec;
+}
 export {
   verifyOverlaySignature,
   validateOverlaySpec,

package/dist/node/index.js

@@ -1,14 +1,126 @@
-// src/spec.ts
-var OVERLAY_SCOPE_ORDER = [
-  "tenantId",
-  "role",
-  "userId",
-  "device",
-  "tags"
-];
-function defineOverlay(spec) {
-  return spec;
+// src/merger.ts
+function applyOverlayModifications(target, overlays, options = {}) {
+  if (!overlays.length) {
+    return target;
+  }
+  const states = target.fields.map((field) => ({
+    key: field.key,
+    field: { ...field },
+    hidden: field.visible === false
+  }));
+  const fieldMap = new Map(states.map((state) => [state.key, state]));
+  let orderSequence = target.fields.map((field) => field.key);
+  const handleMissing = (field, overlayId) => {
+    if (options.strict) {
+      throw new Error(`Overlay "${overlayId}" referenced unknown field "${field}".`);
+    }
+  };
+  overlays.forEach((overlay) => {
+    overlay.modifications.forEach((modification) => {
+      switch (modification.type) {
+        case "hideField": {
+          const state = fieldMap.get(modification.field);
+          if (!state)
+            return handleMissing(modification.field, overlay.overlayId);
+          state.hidden = true;
+          state.field.visible = false;
+          break;
+        }
+        case "renameLabel": {
+          const state = fieldMap.get(modification.field);
+          if (!state)
+            return handleMissing(modification.field, overlay.overlayId);
+          state.field.label = modification.newLabel;
+          break;
+        }
+        case "setDefault": {
+          const state = fieldMap.get(modification.field);
+          if (!state)
+            return handleMissing(modification.field, overlay.overlayId);
+          state.field.defaultValue = modification.value;
+          break;
+        }
+        case "addHelpText": {
+          const state = fieldMap.get(modification.field);
+          if (!state)
+            return handleMissing(modification.field, overlay.overlayId);
+          state.field.helpText = modification.text;
+          break;
+        }
+        case "makeRequired": {
+          const state = fieldMap.get(modification.field);
+          if (!state)
+            return handleMissing(modification.field, overlay.overlayId);
+          state.field.required = modification.required ?? true;
+          break;
+        }
+        case "reorderFields": {
+          const { filtered, missing } = normalizeOrderList(modification.fields, fieldMap);
+          if (missing.length && options.strict) {
+            missing.forEach((field) => handleMissing(field, overlay.overlayId));
+          }
+          orderSequence = applyReorder(orderSequence, filtered);
+          break;
+        }
+        default:
+          break;
+      }
+    });
+  });
+  const visibleFields = [];
+  const seen = new Set;
+  orderSequence.forEach((key) => {
+    const state = fieldMap.get(key);
+    if (!state || state.hidden) {
+      return;
+    }
+    seen.add(key);
+    visibleFields.push(state.field);
+  });
+  states.forEach((state) => {
+    if (state.hidden || seen.has(state.key)) {
+      return;
+    }
+    visibleFields.push(state.field);
+  });
+  visibleFields.forEach((field, index) => {
+    field.order = index;
+    field.visible = true;
+  });
+  return {
+    ...target,
+    fields: visibleFields
+  };
 }
+function normalizeOrderList(fields, fieldMap) {
+  const filtered = [];
+  const missing = [];
+  const seen = new Set;
+  fields.forEach((field) => {
+    if (!field?.trim()) {
+      return;
+    }
+    if (!fieldMap.has(field)) {
+      missing.push(field);
+      return;
+    }
+    if (seen.has(field)) {
+      return;
+    }
+    seen.add(field);
+    filtered.push(field);
+  });
+  return { filtered, missing };
+}
+function applyReorder(sequence, orderedFields) {
+  if (!orderedFields.length) {
+    return sequence;
+  }
+  const orderedSet = new Set(orderedFields);
+  const remainder = sequence.filter((key) => !orderedSet.has(key));
+  return [...orderedFields, ...remainder];
+}
+
 // src/validator.ts
 var TARGET_KEYS = [
   "capability",
@@ -269,129 +381,6 @@ function matches(appliesTo, ctx) {
   return true;
 }
 
-// src/merger.ts
-function applyOverlayModifications(target, overlays, options = {}) {
-  if (!overlays.length) {
-    return target;
-  }
-  const states = target.fields.map((field) => ({
-    key: field.key,
-    field: { ...field },
-    hidden: field.visible === false
-  }));
-  const fieldMap = new Map(states.map((state) => [state.key, state]));
-  let orderSequence = target.fields.map((field) => field.key);
-  const handleMissing = (field, overlayId) => {
-    if (options.strict) {
-      throw new Error(`Overlay "${overlayId}" referenced unknown field "${field}".`);
-    }
-  };
-  overlays.forEach((overlay) => {
-    overlay.modifications.forEach((modification) => {
-      switch (modification.type) {
-        case "hideField": {
-          const state = fieldMap.get(modification.field);
-          if (!state)
-            return handleMissing(modification.field, overlay.overlayId);
-          state.hidden = true;
-          state.field.visible = false;
-          break;
-        }
-        case "renameLabel": {
-          const state = fieldMap.get(modification.field);
-          if (!state)
-            return handleMissing(modification.field, overlay.overlayId);
-          state.field.label = modification.newLabel;
-          break;
-        }
-        case "setDefault": {
-          const state = fieldMap.get(modification.field);
-          if (!state)
-            return handleMissing(modification.field, overlay.overlayId);
-          state.field.defaultValue = modification.value;
-          break;
-        }
-        case "addHelpText": {
-          const state = fieldMap.get(modification.field);
-          if (!state)
-            return handleMissing(modification.field, overlay.overlayId);
-          state.field.helpText = modification.text;
-          break;
-        }
-        case "makeRequired": {
-          const state = fieldMap.get(modification.field);
-          if (!state)
-            return handleMissing(modification.field, overlay.overlayId);
-          state.field.required = modification.required ?? true;
-          break;
-        }
-        case "reorderFields": {
-          const { filtered, missing } = normalizeOrderList(modification.fields, fieldMap);
-          if (missing.length && options.strict) {
-            missing.forEach((field) => handleMissing(field, overlay.overlayId));
-          }
-          orderSequence = applyReorder(orderSequence, filtered);
-          break;
-        }
-        default:
-          break;
-      }
-    });
-  });
-  const visibleFields = [];
-  const seen = new Set;
-  orderSequence.forEach((key) => {
-    const state = fieldMap.get(key);
-    if (!state || state.hidden) {
-      return;
-    }
-    seen.add(key);
-    visibleFields.push(state.field);
-  });
-  states.forEach((state) => {
-    if (state.hidden || seen.has(state.key)) {
-      return;
-    }
-    visibleFields.push(state.field);
-  });
-  visibleFields.forEach((field, index) => {
-    field.order = index;
-    field.visible = true;
-  });
-  return {
-    ...target,
-    fields: visibleFields
-  };
-}
-function normalizeOrderList(fields, fieldMap) {
-  const filtered = [];
-  const missing = [];
-  const seen = new Set;
-  fields.forEach((field) => {
-    if (!field?.trim()) {
-      return;
-    }
-    if (!fieldMap.has(field)) {
-      missing.push(field);
-      return;
-    }
-    if (seen.has(field)) {
-      return;
-    }
-    seen.add(field);
-    filtered.push(field);
-  });
-  return { filtered, missing };
-}
-function applyReorder(sequence, orderedFields) {
-  if (!orderedFields.length) {
-    return sequence;
-  }
-  const orderedSet = new Set(orderedFields);
-  const remainder = sequence.filter((key) => !orderedSet.has(key));
-  return [...orderedFields, ...remainder];
-}
-
 // src/runtime.ts
 class OverlayEngine {
   registry;
@@ -444,7 +433,6 @@ function extractContext(params) {
 }
 
 // src/signer.ts
-import stringify from "fast-json-stable-stringify";
 import {
   constants,
   createPrivateKey,
@@ -452,6 +440,7 @@ import {
   sign,
   verify
 } from "crypto";
+import stringify from "fast-json-stable-stringify";
 function signOverlay(spec, privateKey, options = {}) {
   const algorithm = options.algorithm ?? "ed25519";
   const keyObject = typeof privateKey === "string" || Buffer.isBuffer(privateKey) ? createPrivateKey(privateKey) : privateKey;
@@ -518,6 +507,18 @@ function toIso(value) {
   }
   return value.toISOString();
 }
+
+// src/spec.ts
+var OVERLAY_SCOPE_ORDER = [
+  "tenantId",
+  "role",
+  "userId",
+  "device",
+  "tags"
+];
+function defineOverlay(spec) {
+  return spec;
+}
 export {
   verifyOverlaySignature,
   validateOverlaySpec,

package/dist/node/signer.js

@@ -1,5 +1,4 @@
 // src/signer.ts
-import stringify from "fast-json-stable-stringify";
 import {
   constants,
   createPrivateKey,
@@ -7,6 +6,7 @@ import {
   sign,
   verify
 } from "crypto";
+import stringify from "fast-json-stable-stringify";
 function signOverlay(spec, privateKey, options = {}) {
   const algorithm = options.algorithm ?? "ed25519";
   const keyObject = typeof privateKey === "string" || Buffer.isBuffer(privateKey) ? createPrivateKey(privateKey) : privateKey;

package/dist/react.d.ts

@@ -1,6 +1,6 @@
 import { type DependencyList } from 'react';
-import type { OverlayRenderable } from './types';
 import type { OverlayApplyParams, OverlayRuntimeResult } from './runtime';
 import { OverlayEngine } from './runtime';
+import type { OverlayRenderable } from './types';
 export declare function useOverlay<T extends OverlayRenderable>(engine: OverlayEngine | undefined, params: OverlayApplyParams<T>, deps?: DependencyList): OverlayRuntimeResult<T>;
 export declare function useOverlayFields<T extends OverlayRenderable>(engine: OverlayEngine | undefined, params: OverlayApplyParams<T>, deps?: DependencyList): T['fields'];

package/dist/runtime.d.ts

@@ -1,7 +1,7 @@
 import { type ApplyOverlayOptions } from './merger';
-import { OverlayRegistry, type OverlayLookup } from './registry';
+import { type OverlayLookup, OverlayRegistry } from './registry';
 import type { SignedOverlaySpec } from './spec';
-import type { OverlayRenderable, OverlayAuditEvent } from './types';
+import type { OverlayAuditEvent, OverlayRenderable } from './types';
 export interface OverlayEngineOptions {
     registry: OverlayRegistry;
     audit?: (event: OverlayAuditEvent) => void;

package/dist/signer.js

@@ -1,6 +1,5 @@
 // @bun
 // src/signer.ts
-import stringify from "fast-json-stable-stringify";
 import {
   constants,
   createPrivateKey,
@@ -8,6 +7,7 @@ import {
   sign,
   verify
 } from "crypto";
+import stringify from "fast-json-stable-stringify";
 function signOverlay(spec, privateKey, options = {}) {
   const algorithm = options.algorithm ?? "ed25519";
   const keyObject = typeof privateKey === "string" || Buffer.isBuffer(privateKey) ? createPrivateKey(privateKey) : privateKey;

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import type { SignedOverlaySpec, OverlayScopeContext, OverlayTargetRef } from './spec';
+import type { OverlayScopeContext, OverlayTargetRef, SignedOverlaySpec } from './spec';
 export interface OverlayRenderableField {
     key: string;
     label?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contractspec/lib.overlay-engine",
-  "version": "3.7.6",
+  "version": "3.7.7",
   "description": "Runtime overlay engine for ContractSpec personalization and adaptive UI rendering.",
   "keywords": [
     "contractspec",
@@ -25,14 +25,14 @@
     "dev": "contractspec-bun-build dev",
     "clean": "rimraf dist .turbo",
     "lint": "bun lint:fix",
-    "lint:fix": "eslint src --fix",
-    "lint:check": "eslint src",
+    "lint:fix": "biome check --write --unsafe --only=nursery/useSortedClasses . && biome check --write .",
+    "lint:check": "biome check .",
     "test": "bun test --pass-with-no-tests",
     "prebuild": "contractspec-bun-build prebuild",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@contractspec/lib.contracts-spec": "3.7.6",
+    "@contractspec/lib.contracts-spec": "4.0.0",
     "fast-json-stable-stringify": "^2.1.0"
   },
   "peerDependencies": {