@noy-db/hub 0.3.0-pre.1 → 0.3.0-pre.11

package/dist/indexing/index.js

@@ -7,12 +7,12 @@ import {
   decodeIdxId,
   encodeIdxId,
   isIdxId
-} from "../chunk-V7RWQRG7.js";
+} from "../chunk-3CNQ7FQ3.js";
 import {
   CollectionIndexes
-} from "../chunk-I3TIKTJO.js";
-import "../chunk-M2YKN37S.js";
-import "../chunk-ZYUC53LT.js";
+} from "../chunk-KPZS5QAQ.js";
+import "../chunk-IGJCYUT5.js";
+import "../chunk-FH542DDY.js";
 import "../chunk-PZ5AY32C.js";
 
 // src/with-lookup/indexing/active.ts

package/dist/issue-UB6AA5M6.js

@@ -0,0 +1,19 @@
+import {
+  issueAttestationCore
+} from "./chunk-RKRGDAS7.js";
+import "./chunk-D3EFFFOL.js";
+import "./chunk-ZJADGNYF.js";
+import "./chunk-QQJXBZCO.js";
+import "./chunk-FQQF23MC.js";
+import "./chunk-MSPNM2OM.js";
+import "./chunk-SYMS4546.js";
+import "./chunk-X6CMGUAG.js";
+import "./chunk-LP7BEXCT.js";
+import "./chunk-HUS3J5WM.js";
+import "./chunk-CKZW6P5V.js";
+import "./chunk-FH542DDY.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  issueAttestationCore
+};
+//# sourceMappingURL=issue-UB6AA5M6.js.map

package/dist/json-schema-I22JCYCG.js

@@ -0,0 +1,44 @@
+import "./chunk-PZ5AY32C.js";
+
+// src/with-shape/introspection/json-schema.ts
+function jsonType(t) {
+  switch (t) {
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "array":
+      return "array";
+    case "object":
+      return "object";
+    default:
+      return "string";
+  }
+}
+function buildJsonSchema(desc, base) {
+  const baseProps = base?.["properties"] ?? {};
+  const properties = {};
+  for (const f of desc.fields) {
+    const prop = { ...baseProps[f.key] ?? { type: jsonType(f.type) } };
+    prop["x-label"] = f.label;
+    if (f.unit !== void 0) prop["x-unit"] = f.unit;
+    if (f.semanticType !== void 0) prop["x-semanticType"] = f.semanticType;
+    if (f.sensitivity !== void 0) prop["x-sensitivity"] = f.sensitivity;
+    if (f.widget !== void 0) prop["x-widget"] = f.widget;
+    if (f.editable === false) prop["x-readonly"] = true;
+    if (f.money !== void 0) prop["x-money"] = f.money;
+    if (f.ref !== void 0) prop["x-ref"] = f.ref.target;
+    if (f.dict?.values) {
+      const labels = {};
+      for (const v of f.dict.values) if (v.label !== void 0) labels[v.value] = v.label;
+      if (Object.keys(labels).length) prop["x-enumLabels"] = labels;
+    }
+    if (f.classified !== void 0) prop["x-classified"] = f.classified;
+    properties[f.key] = prop;
+  }
+  return base != null && typeof base === "object" ? { ...base, properties } : { type: "object", properties };
+}
+export {
+  buildJsonSchema
+};
+//# sourceMappingURL=json-schema-I22JCYCG.js.map

package/dist/json-schema-I22JCYCG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/with-shape/introspection/json-schema.ts"],"sourcesContent":["/**\n * `buildJsonSchema` — pure overlay that merges describe() metadata onto a\n * base JSON Schema (from derivePersistedSchema) as `x-` extension keys.\n *\n * When no base JSON Schema is available (non-zod / unknown validator),\n * builds a minimal `{ type:'object', properties }` from describe()'s field\n * type tags. No static `import 'zod'` — validator derivation stays lazy.\n *\n * @module\n */\n\nimport type { CollectionDescription } from './describe.js'\n\n/** Map a DescribedField's type tag to a JSON-Schema `type`. */\nfunction jsonType(t: string): string {\n  switch (t) {\n    case 'number': return 'number'\n    case 'boolean': return 'boolean'\n    case 'array': return 'array'\n    case 'object': return 'object'\n    default: return 'string'\n  }\n}\n\n/** Overlay describe() metadata onto a base JSON Schema (or build a minimal one). */\nexport function buildJsonSchema(desc: CollectionDescription, base?: Record<string, unknown> | null): object {\n  const baseProps = (base?.['properties'] as Record<string, Record<string, unknown>> | undefined) ?? {}\n  const properties: Record<string, Record<string, unknown>> = {}\n  for (const f of desc.fields) {\n    const prop: Record<string, unknown> = { ...(baseProps[f.key] ?? { type: jsonType(f.type) }) }\n    prop['x-label'] = f.label\n    if (f.unit !== undefined) prop['x-unit'] = f.unit\n    if (f.semanticType !== undefined) prop['x-semanticType'] = f.semanticType\n    if (f.sensitivity !== undefined) prop['x-sensitivity'] = f.sensitivity\n    if (f.widget !== undefined) prop['x-widget'] = f.widget\n    if (f.editable === false) prop['x-readonly'] = true\n    if (f.money !== undefined) prop['x-money'] = f.money\n    if (f.ref !== undefined) prop['x-ref'] = f.ref.target\n    if (f.dict?.values) {\n      const labels: Record<string, string> = {}\n      for (const v of f.dict.values) if (v.label !== undefined) labels[v.value] = v.label\n      if (Object.keys(labels).length) prop['x-enumLabels'] = labels\n    }\n    // `x-classified` carries the whole classified block, incl. `equatable` when\n    // set — emitted ungated (boundary note on DescribedField.classified): a\n    // deployment wanting it gated can gate this behind its value-bearing door.\n    if (f.classified !== undefined) prop['x-classified'] = f.classified\n    properties[f.key] = prop\n  }\n  return base != null && typeof base === 'object'\n    ? { ...base, properties }\n    : { type: 'object', properties }\n}\n"],"mappings":";;;AAcA,SAAS,SAAS,GAAmB;AACnC,UAAQ,GAAG;AAAA,IACT,KAAK;AAAU,aAAO;AAAA,IACtB,KAAK;AAAW,aAAO;AAAA,IACvB,KAAK;AAAS,aAAO;AAAA,IACrB,KAAK;AAAU,aAAO;AAAA,IACtB;AAAS,aAAO;AAAA,EAClB;AACF;AAGO,SAAS,gBAAgB,MAA6B,MAA+C;AAC1G,QAAM,YAAa,OAAO,YAAY,KAA6D,CAAC;AACpG,QAAM,aAAsD,CAAC;AAC7D,aAAW,KAAK,KAAK,QAAQ;AAC3B,UAAM,OAAgC,EAAE,GAAI,UAAU,EAAE,GAAG,KAAK,EAAE,MAAM,SAAS,EAAE,IAAI,EAAE,EAAG;AAC5F,SAAK,SAAS,IAAI,EAAE;AACpB,QAAI,EAAE,SAAS,OAAW,MAAK,QAAQ,IAAI,EAAE;AAC7C,QAAI,EAAE,iBAAiB,OAAW,MAAK,gBAAgB,IAAI,EAAE;AAC7D,QAAI,EAAE,gBAAgB,OAAW,MAAK,eAAe,IAAI,EAAE;AAC3D,QAAI,EAAE,WAAW,OAAW,MAAK,UAAU,IAAI,EAAE;AACjD,QAAI,EAAE,aAAa,MAAO,MAAK,YAAY,IAAI;AAC/C,QAAI,EAAE,UAAU,OAAW,MAAK,SAAS,IAAI,EAAE;AAC/C,QAAI,EAAE,QAAQ,OAAW,MAAK,OAAO,IAAI,EAAE,IAAI;AAC/C,QAAI,EAAE,MAAM,QAAQ;AAClB,YAAM,SAAiC,CAAC;AACxC,iBAAW,KAAK,EAAE,KAAK,OAAQ,KAAI,EAAE,UAAU,OAAW,QAAO,EAAE,KAAK,IAAI,EAAE;AAC9E,UAAI,OAAO,KAAK,MAAM,EAAE,OAAQ,MAAK,cAAc,IAAI;AAAA,IACzD;AAIA,QAAI,EAAE,eAAe,OAAW,MAAK,cAAc,IAAI,EAAE;AACzD,eAAW,EAAE,GAAG,IAAI;AAAA,EACtB;AACA,SAAO,QAAQ,QAAQ,OAAO,SAAS,WACnC,EAAE,GAAG,MAAM,WAAW,IACtB,EAAE,MAAM,UAAU,WAAW;AACnC;","names":[]}

package/dist/kernel/cache/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Cache module — barrel export.
+ *
+ * Tree-shakeable: importing this barrel without setting `cache:` on a
+ * Collection does not pull in the LRU runtime, since `Lru` is the only
+ * entry point.
+ */
+export { Lru } from './lru.js';
+export type { LruEntry, LruOptions, LruStats } from './lru.js';
+export { parseBytes, estimateRecordBytes } from './policy.js';

package/dist/kernel/cache/lru.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Generic LRU cache for `Collection`'s lazy hydration mode.
+ *
+ * Backed by a JavaScript `Map`, which preserves insertion order. Promotion
+ * is implemented as `delete()` + `set()` — O(1) on `Map` since both
+ * operations are constant-time. Eviction walks the iterator from the front
+ * (least recently used) until both budgets are satisfied.
+ *
+ * ships in-memory only. The cache is never persisted; on collection
+ * close every entry is dropped. Persisting cache state is a follow-up
+ * once the access patterns from real consumers tell us whether it would
+ * pay back the complexity.
+ */
+export interface LruEntry<V> {
+    /** The cached value. */
+    readonly value: V;
+    /**
+     * Approximate decrypted byte size of the entry. Used by the byte-budget
+     * eviction path. Callers compute this once at insert time and pass it
+     * in — recomputing on every access would dominate the per-record cost.
+     */
+    readonly size: number;
+}
+export interface LruOptions {
+    /** Maximum number of entries before eviction. Required if `maxBytes` is unset. */
+    maxRecords?: number;
+    /** Maximum total bytes before eviction. Computed from per-entry `size`. */
+    maxBytes?: number;
+}
+export interface LruStats {
+    /** Total cache hits since construction (or `resetStats()`). */
+    hits: number;
+    /** Total cache misses since construction (or `resetStats()`). */
+    misses: number;
+    /** Total entries evicted since construction (or `resetStats()`). */
+    evictions: number;
+    /** Current number of cached entries. */
+    size: number;
+    /** Current sum of cached entry sizes (in bytes, approximate). */
+    bytes: number;
+}
+/**
+ * O(1) LRU cache. Both `get()` and `set()` promote the touched entry to
+ * the most-recently-used end. Eviction happens after every insert and
+ * walks the front of the Map iterator dropping entries until both
+ * budgets are satisfied.
+ */
+export declare class Lru<K, V> {
+    private readonly entries;
+    private readonly maxRecords;
+    private readonly maxBytes;
+    private currentBytes;
+    private hits;
+    private misses;
+    private evictions;
+    constructor(options: LruOptions);
+    /**
+     * Look up a key. Hits promote the entry to most-recently-used; misses
+     * return undefined. Both update the running stats counters.
+     */
+    get(key: K): V | undefined;
+    /**
+     * Insert or update a key. If the key already exists, its size is
+     * accounted for and the entry is promoted to MRU. After insertion,
+     * eviction runs to maintain both budgets.
+     */
+    set(key: K, value: V, size: number): void;
+    /**
+     * Remove a key without affecting hit/miss stats. Used by `Collection.delete()`.
+     * Returns true if the key was present.
+     */
+    remove(key: K): boolean;
+    /** True if the cache currently holds an entry for the given key. */
+    has(key: K): boolean;
+    /**
+     * Drop every entry. Stats counters survive — call `resetStats()` if you
+     * want a clean slate. Used by `Collection.invalidate()` on key rotation.
+     */
+    clear(): void;
+    /** Reset hit/miss/eviction counters to zero. Does NOT touch entries. */
+    resetStats(): void;
+    /** Snapshot of current cache statistics. Cheap — no copying. */
+    stats(): LruStats;
+    /**
+     * Iterate over all currently-cached values. Order is least-recently-used
+     * first. Used by tests and devtools — production callers should use
+     * `Collection.scan()` instead.
+     */
+    values(): IterableIterator<V>;
+    /**
+     * Walk the cache from the LRU end and drop entries until both budgets
+     * are satisfied. Called after every `set()`. Single pass — entries are
+     * never re-promoted during eviction.
+     */
+    private evictUntilUnderBudget;
+    private overBudget;
+}

package/dist/kernel/cache/policy.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Cache policy helpers — parse human-friendly byte budgets into raw numbers.
+ *
+ * Accepted shapes (case-insensitive on suffix):
+ *   number       — interpreted as raw bytes
+ *   '1024'       — string of digits, raw bytes
+ *   '50KB'       — kilobytes (×1024)
+ *   '50MB'       — megabytes (×1024²)
+ *   '1GB'        — gigabytes (×1024³)
+ *
+ * Decimals are accepted (`'1.5GB'` → 1610612736 bytes).
+ *
+ * Anything else throws — better to fail loud at construction time than
+ * to silently treat a typo as 0 bytes (which would evict everything).
+ */
+/** Parse a byte budget into a positive integer number of bytes. */
+export declare function parseBytes(input: number | string): number;
+/**
+ * Estimate the in-memory byte size of a decrypted record.
+ *
+ * Uses `JSON.stringify().length` as a stand-in for actual heap usage.
+ * It's a deliberate approximation: real V8 heap size includes pointer
+ * overhead, hidden classes, and string interning that we can't measure
+ * from JavaScript. The JSON length is a stable, monotonic proxy that
+ * costs O(record size) per insert — fine when records are typically
+ * < 1 KB and the cache eviction is the slow path anyway.
+ *
+ * Returns `0` (and the caller must treat it as 1 for accounting) if
+ * stringification throws on circular references; this is documented
+ * but in practice records always come from JSON-decoded envelopes.
+ */
+export declare function estimateRecordBytes(record: unknown): number;