@lssm/lib.contracts-runtime-core 3.0.1

package/dist/redaction.d.ts

@@ -0,0 +1,34 @@
+/** Transforms a value before it is persisted (e.g. stripping secrets). */
+export type RedactionPolicy = (value: unknown) => unknown;
+/**
+ * Recursively replace the values of secret-ish keys with a redaction marker so
+ * durable cache/queue state never persists secrets (AC12). Non-secret data is
+ * preserved structurally.
+ */
+export declare function redactSecrets(value: unknown): unknown;
+/**
+ * Encryption-at-rest seam. The default is identity (no encryption); sensitive
+ * entities plug a real cipher here without the storage core knowing the scheme.
+ */
+export interface EncryptionSeam {
+    encrypt(plaintext: string): string | Promise<string>;
+    decrypt(ciphertext: string): string | Promise<string>;
+}
+export declare const identityEncryption: EncryptionSeam;
+/**
+ * Stable non-cryptographic hash (FNV-1a) used to log query keys without leaking
+ * the input they embed. Observability must never log raw keys (PII).
+ */
+export declare function hashKey(key: string): string;
+export declare const redactionDoc: {
+    id: string;
+    title: string;
+    summary: string;
+    kind: "reference";
+    visibility: "internal";
+    route: string;
+    domain: string;
+    owners: string[];
+    tags: string[];
+    body: string;
+};

package/dist/redaction.js

@@ -0,0 +1,2 @@
+// @bun
+var s=/(?:token|secret|password|passwd|authorization|api[_-]?key|credential|cookie|session)/i;function n(t){if(Array.isArray(t))return t.map(n);if(t===null||typeof t!=="object")return t;let e={};for(let[r,o]of Object.entries(t))e[r]=s.test(r)?"[REDACTED]":n(o);return e}var i={encrypt:(t)=>t,decrypt:(t)=>t};function c(t){let e=2166136261;for(let r=0;r<t.length;r+=1)e^=t.charCodeAt(r),e=Math.imul(e,16777619);return(e>>>0).toString(16).padStart(8,"0")}var a={id:"docs.contracts-runtime-core.redaction",title:"Persisted-state redaction + encryption-at-rest seam",summary:"Secret redaction for durable state plus an encryption-at-rest seam and a PII-safe key hash for logs.",kind:"reference",visibility:"internal",route:"/docs/contracts-runtime-core/redaction",domain:"contracts-runtime-core",owners:["@contractspec-core"],tags:["contracts-runtime-core","security","redaction","encryption"],body:"redactSecrets recursively strips secret-ish keys (token/secret/password/authorization/api-key/credential/cookie/session) so durable cache+queue state never persists secrets (AC12). EncryptionSeam is the encryption-at-rest seam \u2014 default identityEncryption (no-op); sensitive entities plug a real cipher transparently to the storage core. hashKey (FNV-1a) lets observability correlate on a stable key id without logging the raw query key (which embeds input/PII)."};export{c as hashKey,i as identityEncryption,n as redactSecrets,a as redactionDoc};

package/dist/redaction.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/storage/async-storage.native.d.ts

@@ -0,0 +1,23 @@
+import { type KeyedStorageOptions } from './keyed-store.js';
+import type { StoragePort } from './port.js';
+/**
+ * Minimal AsyncStorage surface. Typed locally so this lib takes no hard
+ * dependency on `@react-native-async-storage/async-storage`; the app injects
+ * its own instance (which satisfies this shape).
+ */
+export interface AsyncStorageLike {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    getAllKeys(): Promise<readonly string[]>;
+    clear(): Promise<void>;
+}
+/**
+ * Durable native {@link StoragePort} backed by an injected AsyncStorage
+ * instance. React Native apps pass their AsyncStorage; the lib stays
+ * dependency-free and platform-agnostic at the type level.
+ *
+ * Secret redaction is ON by default (AC12: durable state never persists
+ * secrets). Callers opt out with `redact: undefined` or supply a custom policy.
+ */
+export declare function createAsyncStorage(store: AsyncStorageLike, options?: KeyedStorageOptions): StoragePort;

package/dist/storage/async-storage.native.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/storage/indexeddb.web.d.ts

@@ -0,0 +1,13 @@
+import { type KeyedStorageOptions } from './keyed-store.js';
+import type { StoragePort } from './port.js';
+export interface IndexedDbStorageOptions extends KeyedStorageOptions {
+    databaseName?: string;
+}
+/**
+ * Durable web {@link StoragePort} backed by IndexedDB. Browser-only — apps
+ * import this from the web lane; native lanes use `createAsyncStorage`.
+ *
+ * Secret redaction is ON by default (AC12: durable state never persists
+ * secrets). Callers opt out with `redact: undefined` or supply a custom policy.
+ */
+export declare function createIndexedDbStorage(options?: IndexedDbStorageOptions): StoragePort;

package/dist/storage/indexeddb.web.js

@@ -0,0 +1,2 @@
+// @bun
+var f=/(?:token|secret|password|passwd|authorization|api[_-]?key|credential|cookie|session)/i;function d(e){if(Array.isArray(e))return e.map(d);if(e===null||typeof e!=="object")return e;let n={};for(let[t,r]of Object.entries(e))n[t]=f.test(t)?"[REDACTED]":d(r);return n}var u={encrypt:(e)=>e,decrypt:(e)=>e};function h(e){let n=2166136261;for(let t=0;t<e.length;t+=1)n^=e.charCodeAt(t),n=Math.imul(n,16777619);return(n>>>0).toString(16).padStart(8,"0")}var D={id:"docs.contracts-runtime-core.redaction",title:"Persisted-state redaction + encryption-at-rest seam",summary:"Secret redaction for durable state plus an encryption-at-rest seam and a PII-safe key hash for logs.",kind:"reference",visibility:"internal",route:"/docs/contracts-runtime-core/redaction",domain:"contracts-runtime-core",owners:["@contractspec-core"],tags:["contracts-runtime-core","security","redaction","encryption"],body:"redactSecrets recursively strips secret-ish keys (token/secret/password/authorization/api-key/credential/cookie/session) so durable cache+queue state never persists secrets (AC12). EncryptionSeam is the encryption-at-rest seam \u2014 default identityEncryption (no-op); sensitive entities plug a real cipher transparently to the storage core. hashKey (FNV-1a) lets observability correlate on a stable key id without logging the raw query key (which embeds input/PII)."};function g(e,n={}){let t=n.encryption??u,r=n.redact,i=n.namespace??"",y=(o)=>`${i}${o}`,l=(o)=>i!==""&&o.startsWith(i)?o.slice(i.length):o;return{async get(o){let s=await e.getItem(y(o));if(s===null)return;let a=await t.decrypt(s);return JSON.parse(a)},async set(o,s){let a=JSON.stringify(r===void 0?s:r(s));await e.setItem(y(o),await t.encrypt(a))},async remove(o){await e.removeItem(y(o))},async keys(o){let s=await e.keys(),a=i===""?s:s.filter((p)=>p.startsWith(i)).map(l);return o===void 0?a:a.filter((p)=>p.startsWith(o))},async clear(){await e.clear()}}}var w="contractspec-runtime",m="kv";function c(e){return new Promise((n,t)=>{e.onsuccess=()=>n(e.result),e.onerror=()=>t(e.error)})}function S(e){return new Promise((n,t)=>{let r=indexedDB.open(e,1);r.onupgradeneeded=()=>{r.result.createObjectStore(m)},r.onsuccess=()=>n(r.result),r.onerror=()=>t(r.error)})}function k(e){let n=S(e),t=async(r)=>(await n).transaction(m,r).objectStore(m);return{async getItem(r){return await c((await t("readonly")).get(r))??null},async setItem(r,i){await c((await t("readwrite")).put(i,r))},async removeItem(r){await c((await t("readwrite")).delete(r))},async keys(){return(await c((await t("readonly")).getAllKeys())).map(String)},async clear(){await c((await t("readwrite")).clear())}}}function I(e={}){let{databaseName:n,...t}=e;return g(k(n??w),{redact:d,...t})}export{I as createIndexedDbStorage};

package/dist/storage/keyed-store.d.ts

@@ -0,0 +1,25 @@
+import { type EncryptionSeam, type RedactionPolicy } from '../redaction.js';
+import type { StoragePort } from './port.js';
+/** Minimal async string key/value driver a platform binding adapts to. */
+export interface StringKvDriver {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    keys(): Promise<readonly string[]>;
+    clear(): Promise<void>;
+}
+export interface KeyedStorageOptions {
+    /** Redaction applied to values before persistence (default: none). */
+    redact?: RedactionPolicy;
+    /** Encryption-at-rest seam wrapping the serialized JSON (default: identity). */
+    encryption?: EncryptionSeam;
+    /** Key namespace prefix applied to every driver key (default: none). */
+    namespace?: string;
+}
+/**
+ * Builds a durable {@link StoragePort} over a string KV driver, adding JSON
+ * (de)serialization, optional secret redaction, the encryption-at-rest seam,
+ * and key namespacing. This is the shared, fully testable core behind the
+ * platform bindings (IndexedDB on web, AsyncStorage on native).
+ */
+export declare function createKeyedStorage(driver: StringKvDriver, options?: KeyedStorageOptions): StoragePort;

package/dist/storage/keyed-store.js

@@ -0,0 +1,2 @@
+// @bun
+var u=/(?:token|secret|password|passwd|authorization|api[_-]?key|credential|cookie|session)/i;function p(t){if(Array.isArray(t))return t.map(p);if(t===null||typeof t!=="object")return t;let r={};for(let[n,c]of Object.entries(t))r[n]=u.test(n)?"[REDACTED]":p(c);return r}var d={encrypt:(t)=>t,decrypt:(t)=>t};function g(t){let r=2166136261;for(let n=0;n<t.length;n+=1)r^=t.charCodeAt(n),r=Math.imul(r,16777619);return(r>>>0).toString(16).padStart(8,"0")}var l={id:"docs.contracts-runtime-core.redaction",title:"Persisted-state redaction + encryption-at-rest seam",summary:"Secret redaction for durable state plus an encryption-at-rest seam and a PII-safe key hash for logs.",kind:"reference",visibility:"internal",route:"/docs/contracts-runtime-core/redaction",domain:"contracts-runtime-core",owners:["@contractspec-core"],tags:["contracts-runtime-core","security","redaction","encryption"],body:"redactSecrets recursively strips secret-ish keys (token/secret/password/authorization/api-key/credential/cookie/session) so durable cache+queue state never persists secrets (AC12). EncryptionSeam is the encryption-at-rest seam \u2014 default identityEncryption (no-op); sensitive entities plug a real cipher transparently to the storage core. hashKey (FNV-1a) lets observability correlate on a stable key id without logging the raw query key (which embeds input/PII)."};function k(t,r={}){let n=r.encryption??d,c=r.redact,o=r.namespace??"",a=(e)=>`${o}${e}`,m=(e)=>o!==""&&e.startsWith(o)?e.slice(o.length):e;return{async get(e){let i=await t.getItem(a(e));if(i===null)return;let s=await n.decrypt(i);return JSON.parse(s)},async set(e,i){let s=JSON.stringify(c===void 0?i:c(i));await t.setItem(a(e),await n.encrypt(s))},async remove(e){await t.removeItem(a(e))},async keys(e){let i=await t.keys(),s=o===""?i:i.filter((y)=>y.startsWith(o)).map(m);return e===void 0?s:s.filter((y)=>y.startsWith(e))},async clear(){await t.clear()}}}export{k as createKeyedStorage};

package/dist/storage/keyed-store.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/storage/memory.d.ts

@@ -0,0 +1,11 @@
+import type { StoragePort } from './port.js';
+/**
+ * In-memory {@link StoragePort} default for the B1a synchronous engine and
+ * tests. Non-durable (lost on restart) — durable platform variants land in
+ * B1b/#7.
+ *
+ * Values are structurally cloned on write and read so callers cannot mutate
+ * stored state by reference, matching the isolation a serializing durable store
+ * provides.
+ */
+export declare function createMemoryStorage(): StoragePort;

package/dist/storage/memory.js

@@ -0,0 +1,2 @@
+// @bun
+function o(){let r=new Map;return{get:async(e)=>{let n=r.get(e);return n===void 0?void 0:structuredClone(n)},set:async(e,n)=>{r.set(e,structuredClone(n))},remove:async(e)=>{r.delete(e)},keys:async(e)=>{let n=[...r.keys()];return e===void 0?n:n.filter((t)=>t.startsWith(e))},clear:async()=>{r.clear()}}}export{o as createMemoryStorage};

package/dist/storage/memory.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/storage/port.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Durable key/value storage port — the I/O-free contract behind which platform
+ * defaults live (in-memory for B1a; IndexedDB on web and SQLite/AsyncStorage on
+ * native in B1b/#7). It is intentionally value-agnostic: the engine layers the
+ * cache-entry and mutation-queue shapes on top, namespacing by key prefix.
+ *
+ * Implementations persist JSON-serializable values and own
+ * serialization, secret redaction, and the encryption-at-rest seam (AC12);
+ * the contract here stays free of any concrete I/O.
+ */
+export interface StoragePort {
+    /** Read a value by key, or `undefined` when absent. */
+    get<TValue = unknown>(key: string): Promise<TValue | undefined>;
+    /** Write (overwrite) a value by key. */
+    set<TValue = unknown>(key: string, value: TValue): Promise<void>;
+    /** Remove a single key. No-op when absent. */
+    remove(key: string): Promise<void>;
+    /** Enumerate keys, optionally filtered by prefix (used by GC + queue scans). */
+    keys(prefix?: string): Promise<readonly string[]>;
+    /** Remove every key in the store. */
+    clear(): Promise<void>;
+}
+export declare const storagePortDoc: {
+    id: string;
+    title: string;
+    summary: string;
+    kind: "reference";
+    visibility: "internal";
+    route: string;
+    domain: string;
+    owners: string[];
+    tags: string[];
+    body: string;
+};

package/dist/storage/port.js

@@ -0,0 +1,2 @@
+// @bun
+var e={id:"docs.contracts-runtime-core.storage-port",title:"Durable storage port (I/O-free contract)",summary:"Value-agnostic durable key/value port; platform impls own serialization, redaction, and encryption-at-rest.",kind:"reference",visibility:"internal",route:"/docs/contracts-runtime-core/storage-port",domain:"contracts-runtime-core",owners:["@contractspec-core"],tags:["contracts-runtime-core","storage","persistence","port"],body:"Durable key/value StoragePort: get/set/remove/keys/clear. Intentionally value-agnostic \u2014 the engine layers CacheEntry and MutationQueueEntry shapes on top and namespaces by key prefix. keys(prefix?) supports GC and offline-queue scans. Implementations persist JSON-serializable values and own serialization, per-contract secret redaction, and the encryption-at-rest seam (AC12). B1a ships an in-memory default (createMemoryStorage); IndexedDB (web) and SQLite/AsyncStorage (native) platform variants land in B1b/#7 behind this same contract."};export{e as storagePortDoc};

package/dist/transport.d.ts

@@ -0,0 +1,53 @@
+import type { QueryEnvelope, QueryResultEnvelope } from '@lssm/lib.contracts-spec/query/envelope';
+import type { InvalidationTag } from '@lssm/lib.contracts-spec/query/invalidation';
+import type { VersionToken } from '@lssm/lib.contracts-spec/query/version-token';
+import type { ContractResult } from '@lssm/lib.contracts-spec/results';
+/**
+ * Per-call context threaded through a transport. The `principal` is opaque to
+ * the engine and every adapter: it is carried end-to-end unchanged and MUST
+ * NOT be stripped by the canonical envelope/result path (AC14). Enforcement of
+ * `policy.auth` stays in authos/identity-rbac, not here.
+ */
+export interface TransportContext {
+    /** Opaque auth principal / session token. Carried through, never inspected by core. */
+    principal?: unknown;
+    /** Correlation id for observability + tracing. */
+    correlationId?: string;
+    /** Cooperative cancellation signal. */
+    signal?: AbortSignal;
+    /** Transport-specific request metadata (e.g. headers). */
+    meta?: Record<string, unknown>;
+}
+/**
+ * A server-pushed invalidation notification. The per-entity `versionToken`
+ * doubles as the realtime invalidation token, so realtime delivery and
+ * optimistic-concurrency detection share one vocabulary.
+ */
+export interface InvalidationEvent {
+    tags: readonly InvalidationTag[];
+    versionToken?: VersionToken;
+}
+/** Handler invoked when subscribed tags are invalidated. */
+export type InvalidationHandler = (event: InvalidationEvent) => void;
+/**
+ * The single `Transport` port. REST, MCP, WebSocket, and in-memory are
+ * interchangeable adapters behind it; clients/providers never invent parallel
+ * envelopes. `subscribe` is the realtime seam — defined now, full delivery is a
+ * follow-on (the worker migration consumes this seam in Phase 7).
+ */
+export interface Transport {
+    execute<TInput = unknown, TData = unknown>(envelope: QueryEnvelope<TInput>, ctx?: TransportContext): Promise<ContractResult<QueryResultEnvelope<TData>>>;
+    subscribe?(tags: readonly InvalidationTag[], handler: InvalidationHandler): () => void;
+}
+export declare const transportPortDoc: {
+    id: string;
+    title: string;
+    summary: string;
+    kind: "reference";
+    visibility: "internal";
+    route: string;
+    domain: string;
+    owners: string[];
+    tags: string[];
+    body: string;
+};

package/dist/transport.js

@@ -0,0 +1,3 @@
+// @bun
+var e={id:"docs.contracts-runtime-core.transport",title:"Transport port + absorbed data-transmission concept map",summary:"One Transport port carries the canonical protocol; each former data-transmission concept has an explicit home.",kind:"reference",visibility:"internal",route:"/docs/contracts-runtime-core/transport",domain:"contracts-runtime-core",owners:["@contractspec-core"],tags:["contracts-runtime-core","transport","data-transmission","port"],body:["The single Transport port: execute(envelope, ctx) \u2192 Promise<ContractResult<QueryResultEnvelope>>, plus an optional subscribe(tags, handler) realtime seam. REST/MCP/WebSocket/in-memory are interchangeable adapters behind it.","","Absorbed data-transmission concept map (each former concept has exactly one explicit home \u2014 no parallel transport types):","- idempotency \u2192 ContractResult success field (ContractResultIdempotency{key,replayed?,firstSeenAt?} on ContractSuccess.idempotency). NOT a transport argument.","- subscriptions \u2192 Transport.subscribe(tags, handler) seam (no spec type, by design); the version token doubles as the realtime invalidation token. Full delivery is a follow-on; the realtime worker migrates onto this seam in Phase 7.","- invalidation \u2192 the InvalidationTag{entity,id?} vocabulary (contracts-spec/query/invalidation) shared by optimistic updates, offline-queue replay, and realtime broadcast; mutations declare the tags they invalidate.","- consistency levels \u2192 the typed QueryEnvelope.consistency request field and ContractSuccess.consistency applied field (QueryConsistency = eventual | read-your-writes | strong, default read-your-writes). Typed, never prose. Subsumes the former DataFetchConsistency incl. read-your-writes.","","TransportContext.principal is opaque and carried end-to-end unchanged (AC14, no-strip); policy.auth enforcement stays in authos/identity-rbac."].join(`
+`)};export{e as transportPortDoc};

package/package.json

@@ -0,0 +1,219 @@
+{
+  "name": "@lssm/lib.contracts-runtime-core",
+  "version": "3.0.1",
+  "description": "Framework-neutral in-house query/cache/offline engine and Transport port for ContractSpec data fetching",
+  "keywords": [
+    "contractspec",
+    "contracts",
+    "runtime",
+    "transport",
+    "cache",
+    "offline",
+    "core",
+    "typescript"
+  ],
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "publish:pkg": "bun publish --tolerate-republish --ignore-scripts --verbose",
+    "publish:pkg:canary": "bun publish:pkg --tag canary",
+    "build": "contractspec-bun-build build",
+    "build:bundle": "contractspec-bun-build transpile",
+    "build:types": "contractspec-bun-build types",
+    "clean": "rimraf dist .turbo",
+    "dev": "contractspec-bun-build dev",
+    "lint": "bun run lint:fix",
+    "lint:fix": "node ../../../scripts/biome.cjs check --write --unsafe --only=nursery/useSortedClasses . && node ../../../scripts/biome.cjs check --write .",
+    "lint:check": "node ../../../scripts/biome.cjs check .",
+    "prebuild": "contractspec-bun-build prebuild",
+    "smoke:exports": "node scripts/smoke-approval-exports.mjs --mode=artifact",
+    "smoke:exports:runtime": "node scripts/smoke-approval-exports.mjs --mode=runtime --entry=dist/index.js",
+    "typecheck": "tsgo --noEmit -p tsconfig.json"
+  },
+  "peerDependencies": {
+    "typescript": "^7.0.2 || ^6.0.3"
+  },
+  "dependencies": {
+    "@lssm/lib.contracts-spec": "^17.3.2",
+    "@lssm/lib.observability": "^5.0.2"
+  },
+  "devDependencies": {
+    "@lssm-tech/tool.bun": "5.0.3",
+    "@lssm-tech/tool.typescript": "5.0.1",
+    "typescript": "^7.0.2"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "browser": "./dist/browser/index.js",
+      "bun": "./dist/index.js",
+      "node": "./dist/node/index.js",
+      "default": "./dist/index.js"
+    },
+    "./contracts-runtime-core.feature": {
+      "types": "./dist/contracts-runtime-core.feature.d.ts",
+      "browser": "./dist/browser/contracts-runtime-core.feature.js",
+      "bun": "./dist/contracts-runtime-core.feature.js",
+      "node": "./dist/node/contracts-runtime-core.feature.js",
+      "default": "./dist/contracts-runtime-core.feature.js"
+    },
+    "./observability": {
+      "types": "./dist/observability.d.ts",
+      "browser": "./dist/browser/observability.js",
+      "bun": "./dist/observability.js",
+      "node": "./dist/node/observability.js",
+      "default": "./dist/observability.js"
+    },
+    "./storage/async-storage": {
+      "types": "./dist/storage/async-storage.native.d.ts",
+      "react-native": "./dist/native/storage/async-storage.native.js",
+      "default": "./dist/native/storage/async-storage.native.js"
+    },
+    "./storage/indexeddb": {
+      "types": "./dist/storage/indexeddb.web.d.ts",
+      "browser": "./dist/browser/storage/indexeddb.web.js",
+      "default": "./dist/storage/indexeddb.web.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "exports": {
+      ".": {
+        "types": "./dist/index.d.ts",
+        "browser": "./dist/browser/index.js",
+        "bun": "./dist/index.js",
+        "node": "./dist/node/index.js",
+        "default": "./dist/index.js"
+      },
+      "./contracts-runtime-core.feature": {
+        "types": "./dist/contracts-runtime-core.feature.d.ts",
+        "browser": "./dist/browser/contracts-runtime-core.feature.js",
+        "bun": "./dist/contracts-runtime-core.feature.js",
+        "node": "./dist/node/contracts-runtime-core.feature.js",
+        "default": "./dist/contracts-runtime-core.feature.js"
+      },
+      "./observability": {
+        "types": "./dist/observability.d.ts",
+        "browser": "./dist/browser/observability.js",
+        "bun": "./dist/observability.js",
+        "node": "./dist/node/observability.js",
+        "default": "./dist/observability.js"
+      },
+      "./storage/async-storage": {
+        "types": "./dist/storage/async-storage.native.d.ts",
+        "react-native": "./dist/native/storage/async-storage.native.js",
+        "default": "./dist/native/storage/async-storage.native.js"
+      },
+      "./storage/indexeddb": {
+        "types": "./dist/storage/indexeddb.web.d.ts",
+        "browser": "./dist/browser/storage/indexeddb.web.js",
+        "default": "./dist/storage/indexeddb.web.js"
+      }
+    },
+    "registry": "https://registry.npmjs.org"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lssm-tech/contractspec.git",
+    "directory": "packages/libs/contracts-runtime-core"
+  },
+  "homepage": "https://contractspec.io",
+  "contractspec": {
+    "catalog": {
+      "family": "runtime",
+      "kind": "library",
+      "status": "active",
+      "adoptionMode": "adoptable",
+      "stability": "stable",
+      "platforms": [
+        "server"
+      ],
+      "runtimes": [
+        "node"
+      ],
+      "entrypoints": [
+        ".",
+        "./contracts-runtime-core.feature",
+        "./observability",
+        "./storage/async-storage",
+        "./storage/indexeddb"
+      ],
+      "documentation": [
+        {
+          "title": "Lib Contracts Runtime Core documentation",
+          "url": "https://www.npmjs.com/package/%40lssm%2Flib.contracts-runtime-core",
+          "kind": "readme"
+        }
+      ],
+      "examples": [],
+      "replacements": [],
+      "capabilities": [
+        {
+          "id": "package.lssm.tech.lib.contracts.runtime.core",
+          "title": "Lib Contracts Runtime Core",
+          "description": "Framework-neutral in-house query/cache/offline engine and Transport port for ContractSpec data fetching",
+          "status": "active",
+          "useCases": [
+            "Adopt framework-neutral in-house query/cache/offline engine and transport port for contractspec data fetching"
+          ],
+          "aliases": [
+            "contractspec",
+            "contracts",
+            "runtime",
+            "transport",
+            "cache",
+            "offline",
+            "core",
+            "typescript",
+            "lib"
+          ],
+          "pythonEquivalents": [],
+          "canonicalImports": [
+            {
+              "from": "@lssm/lib.contracts-runtime-core",
+              "symbols": []
+            },
+            {
+              "from": "@lssm/lib.contracts-runtime-core/contracts-runtime-core.feature",
+              "symbols": []
+            },
+            {
+              "from": "@lssm/lib.contracts-runtime-core/observability",
+              "symbols": []
+            },
+            {
+              "from": "@lssm/lib.contracts-runtime-core/storage/async-storage",
+              "symbols": []
+            },
+            {
+              "from": "@lssm/lib.contracts-runtime-core/storage/indexeddb",
+              "symbols": []
+            }
+          ],
+          "constraints": {
+            "platforms": [
+              "server"
+            ],
+            "runtimes": [
+              "node"
+            ],
+            "avoidWhen": [
+              "The @lssm/lib.contracts-runtime-core package constraints do not match the target runtime or platform."
+            ],
+            "requires": [
+              "TypeScript"
+            ]
+          },
+          "alternatives": [],
+          "relationships": [],
+          "resolutionPriority": 50
+        }
+      ]
+    }
+  }
+}