@noy-db/hub 0.7.0-pre.10 → 0.7.0-pre.12

package/dist/{chunk-2DGBRE4K.js → chunk-4OZNXTO4.js}

@@ -1,7 +1,7 @@
 import {
   FieldFrozenError,
   InvariantError
-} from "./chunk-SW4TOSJL.js";
+} from "./chunk-7O3Y4PPD.js";
 
 // src/with-audit/guards/executor.ts
 var GuardExecutor = {
@@ -77,4 +77,4 @@ function deepEqual(a, b) {
 export {
   GuardExecutor
 };
-//# sourceMappingURL=chunk-2DGBRE4K.js.map
+//# sourceMappingURL=chunk-4OZNXTO4.js.map

package/dist/{chunk-FZWAGG5T.js → chunk-5FUULQ6F.js}

@@ -201,7 +201,7 @@ var engineCtx = (ctx) => ({
 function withClassified() {
   return {
     async reveal(ctx, id, field) {
-      const { revealSealedField } = await import("./reveal-PI6ADRQU.js");
+      const { revealSealedField } = await import("./reveal-DDQBDWPM.js");
       const value = await revealSealedField({
         collection: ctx.collection,
         encrypted: ctx.encrypted,
@@ -213,26 +213,26 @@ function withClassified() {
       return value;
     },
     async verify(ctx, id, field, candidate) {
-      const { verifyDigestField } = await import("./verify-R6CCBUA3.js");
+      const { verifyDigestField } = await import("./verify-JBXCAGDL.js");
       const verdict = await verifyDigestField(engineCtx(ctx), id, field, candidate, policyOf(ctx.spec));
       await ctx.onAccess?.("verify", id);
       return verdict;
     },
     async verifyText(ctx, id, field, candidate) {
-      const { verifyTextField } = await import("./verify-R6CCBUA3.js");
+      const { verifyTextField } = await import("./verify-JBXCAGDL.js");
       const verdict = await verifyTextField(engineCtx(ctx), id, field, candidate, ctx.spec.verifyNormalize ?? "password");
       await ctx.onAccess?.("verify", id);
       return verdict;
     },
     async matchGroup(ctx, id, answers, opts) {
-      const { matchGroupFields } = await import("./verify-R6CCBUA3.js");
+      const { matchGroupFields } = await import("./verify-JBXCAGDL.js");
       const members = (ctx.groupMembers ?? []).map((m) => ({ field: m.field, policy: policyOf(m.spec) }));
       const result = await matchGroupFields(engineCtx(ctx), id, answers, members, opts);
       await ctx.onAccess?.("verify", id);
       return result;
     },
     async computeTarget(ctx, field, candidate, costByte) {
-      const { computeBidxTarget } = await import("./find-SVZHMEQI.js");
+      const { computeBidxTarget } = await import("./find-LC7P63MX.js");
       const dek = await ctx.getDEK();
       return computeBidxTarget(candidate, policyOf(ctx.spec).normalize, dek, ctx.collection, field, costByte);
     }
@@ -244,4 +244,4 @@ export {
   classified,
   withClassified
 };
-//# sourceMappingURL=chunk-FZWAGG5T.js.map
+//# sourceMappingURL=chunk-5FUULQ6F.js.map

package/dist/{chunk-P7KJME6C.js → chunk-6YXCPL4T.js}

@@ -1,6 +1,6 @@
 import {
   SealedRecordNotEnabledError
-} from "./chunk-SW4TOSJL.js";
+} from "./chunk-7O3Y4PPD.js";
 
 // src/with-audit/sealed-record/strategy.ts
 var NO_SEALED_RECORD = {
@@ -18,4 +18,4 @@ var NO_SEALED_RECORD = {
 export {
   NO_SEALED_RECORD
 };
-//# sourceMappingURL=chunk-P7KJME6C.js.map
+//# sourceMappingURL=chunk-6YXCPL4T.js.map

package/dist/{chunk-XJP66QEN.js → chunk-7BE7ZDVQ.js}

@@ -1,7 +1,381 @@
+import {
+  jsonSchemaToFields
+} from "./chunk-VYYM3MEN.js";
+import {
+  derivePersistedSchema,
+  isZod4Schema
+} from "./chunk-URHRIAV6.js";
+import {
+  loadPersistedSchema
+} from "./chunk-WWNYSV7S.js";
+import {
+  isStaticDictDescriptor
+} from "./chunk-TRGTKX5E.js";
 import {
   DerivationCycleError,
   MaterializedViewCycleError
-} from "./chunk-SW4TOSJL.js";
+} from "./chunk-7O3Y4PPD.js";
+
+// src/with-shape/introspection/field-meta.ts
+var FieldMetaUnknownFieldError = class extends Error {
+  constructor(collection, key) {
+    super(`fieldMeta for collection "${collection}" references unknown field "${key}". Declare it in the schema/config or remove the fieldMeta entry.`);
+    this.collection = collection;
+    this.key = key;
+    this.name = "FieldMetaUnknownFieldError";
+  }
+  collection;
+  key;
+};
+function validateFieldMetaKeys(collection, fieldMeta, knownFields) {
+  for (const key of Object.keys(fieldMeta)) {
+    if (!knownFields.has(key)) throw new FieldMetaUnknownFieldError(collection, key);
+  }
+}
+function humanizeFieldKey(key) {
+  return key.replace(/[_-]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").trim().split(/\s+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+function resolveFieldMeta(key, inputs) {
+  const { channel, zodMeta, inferred } = inputs;
+  const pick = (k) => channel?.[k] ?? zodMeta?.[k] ?? inferred?.[k];
+  const description = pick("description");
+  const semanticType = pick("semanticType");
+  const unit = pick("unit");
+  const sensitivity = pick("sensitivity");
+  const aggregate = pick("aggregate");
+  const aliases = pick("aliases");
+  const displayFor = pick("displayFor");
+  const widget = pick("widget");
+  const group = pick("group");
+  const order = pick("order");
+  return {
+    label: pick("label") ?? humanizeFieldKey(key),
+    ...description !== void 0 ? { description } : {},
+    ...semanticType !== void 0 ? { semanticType } : {},
+    ...unit !== void 0 ? { unit } : {},
+    ...sensitivity !== void 0 ? { sensitivity } : {},
+    ...aggregate !== void 0 ? { aggregate } : {},
+    ...aliases !== void 0 ? { aliases } : {},
+    ...displayFor !== void 0 ? { displayFor } : {},
+    ...widget !== void 0 ? { widget } : {},
+    ...group !== void 0 ? { group } : {},
+    ...order !== void 0 ? { order } : {}
+  };
+}
+
+// src/with-shape/introspection/describe.ts
+var ZOD_META_KEYS = /* @__PURE__ */ new Set([
+  "label",
+  "description",
+  "unit",
+  "semanticType",
+  "sensitivity",
+  "aggregate",
+  "aliases",
+  "displayFor",
+  "group",
+  "order"
+]);
+function schemaFieldKeys(schema) {
+  let s = schema;
+  for (let depth = 0; depth < 10; depth++) {
+    if (s === null || typeof s !== "object") return void 0;
+    const shape = s.shape;
+    if (shape !== null && typeof shape === "object") {
+      const keys = Object.keys(shape);
+      return keys.length > 0 ? keys : void 0;
+    }
+    const def = s._def;
+    if (def?.schema !== void 0 && def.effect?.type === "refinement") {
+      s = def.schema;
+      continue;
+    }
+    return void 0;
+  }
+  return void 0;
+}
+async function deriveZodFields(schema) {
+  const envelope = await derivePersistedSchema(schema);
+  if (!envelope.jsonSchema) return {};
+  const isZod4 = isZod4Schema(schema);
+  const jsonSchema = envelope.jsonSchema;
+  const fieldDescriptors = jsonSchemaToFields(jsonSchema, "live-validator");
+  const propertiesRaw = jsonSchema["properties"];
+  const result = {};
+  for (const [key, descriptor] of Object.entries(fieldDescriptors)) {
+    let meta;
+    if (isZod4 && propertiesRaw) {
+      const prop = propertiesRaw[key];
+      if (prop) {
+        const extracted = {};
+        let hasAny = false;
+        for (const mk of ZOD_META_KEYS) {
+          if (mk in prop) {
+            extracted[mk] = prop[mk];
+            hasAny = true;
+          }
+        }
+        if (hasAny) meta = extracted;
+      }
+    }
+    result[key] = {
+      type: descriptor.type,
+      optional: descriptor.optional === true,
+      ...descriptor.constraints !== void 0 ? { constraints: descriptor.constraints } : {},
+      ...meta !== void 0 ? { meta } : {}
+    };
+  }
+  return result;
+}
+async function resolveDescribeFieldIds(store, vaultName, collectionName, getDEK) {
+  let dek;
+  try {
+    dek = await getDEK(collectionName);
+  } catch {
+    return {};
+  }
+  const persisted = await loadPersistedSchema(store, vaultName, collectionName, dek);
+  return persisted?.fieldIds !== void 0 ? { fieldIds: persisted.fieldIds } : {};
+}
+function deriveWidget(opts) {
+  if (opts.resolvedWidget !== void 0) return opts.resolvedWidget;
+  switch (opts.semanticType) {
+    case "date":
+    case "datetime":
+      return "date";
+    case "currency":
+      return "money";
+    case "entity":
+      return "ref-select";
+    case "url":
+      return "url";
+    case "email":
+      return "email";
+    case "percent":
+      return "number";
+  }
+  if (opts.dict !== void 0 || opts.lookup !== void 0) return "select";
+  if (opts.blob !== void 0) return "file";
+  if (opts.type === "boolean") return "checkbox";
+  if (opts.type === "number") return "number";
+  return "text";
+}
+function buildDescription(input) {
+  const { collection, fieldMeta, moneyFields, dictKeyFields, lookupFields, computed, refs, zodFields, schema, dictLabels, meta, i18nFields, classified, taint, fieldIds } = input;
+  const lookupFragments = input.viaFragments?.["lookup"]?.lookupFields;
+  const blobFragments = input.viaFragments?.["blob"]?.blobFields;
+  const validatorKeys = zodFields !== void 0 && Object.keys(zodFields).length > 0 ? Object.keys(zodFields) : schemaFieldKeys(schema);
+  const canEnumerateFields = validatorKeys !== void 0;
+  if (canEnumerateFields && fieldMeta !== void 0) {
+    const knownFields = /* @__PURE__ */ new Set([
+      ...Object.keys(moneyFields ?? {}),
+      ...Object.keys(dictKeyFields ?? {}),
+      ...Object.keys(refs),
+      ...Object.keys(computed ?? {}),
+      ...validatorKeys ?? [],
+      ...Object.keys(i18nFields ?? {}),
+      ...Object.keys(lookupFields ?? {}),
+      ...Object.keys(blobFragments ?? {}),
+      ...Object.keys(classified ?? {})
+    ]);
+    validateFieldMetaKeys(collection, fieldMeta, knownFields);
+  }
+  const allKeys = /* @__PURE__ */ new Set([
+    ...Object.keys(moneyFields ?? {}),
+    ...Object.keys(dictKeyFields ?? {}),
+    ...Object.keys(lookupFields ?? {}),
+    ...Object.keys(refs),
+    ...Object.keys(computed ?? {}),
+    ...Object.keys(fieldMeta ?? {}),
+    ...Object.keys(zodFields ?? {}),
+    ...Object.keys(i18nFields ?? {}),
+    ...Object.keys(classified ?? {}),
+    ...Object.keys(blobFragments ?? {})
+  ]);
+  const fields = [];
+  for (const key of [...allKeys].sort()) {
+    const zod = zodFields?.[key];
+    const money = moneyFields?.[key];
+    const dict = dictKeyFields?.[key];
+    const lookupDesc = lookupFields?.[key];
+    const refDesc = refs[key];
+    const isComputed = computed !== void 0 && key in computed;
+    const i18nDesc = i18nFields?.[key];
+    const cls = classified?.[key];
+    const blobFragmentEntry = blobFragments?.[key];
+    const taintPosture = taint?.postures.get(key);
+    let type = zod?.type ?? "unknown";
+    const inferred = {};
+    let moneyBlock;
+    let dictBlock;
+    let refBlock;
+    let lookupBlock;
+    let blobBlock;
+    if (money) {
+      type = "number";
+      inferred.semanticType = "currency";
+      inferred.aggregate = "sum";
+      const currency = money.soleCurrency();
+      const scale = currency !== void 0 ? money.scaleFor(currency) : void 0;
+      moneyBlock = {
+        mode: money.mode,
+        ...currency !== void 0 ? { currency } : {},
+        ...scale !== void 0 ? { scale } : {},
+        ...money.rounding !== void 0 ? { rounding: money.rounding } : {}
+      };
+    } else if (refDesc) {
+      type = refDesc.isArray ? "array" : "string";
+      inferred.semanticType = "entity";
+      refBlock = {
+        target: refDesc.target,
+        mode: refDesc.mode,
+        ...refDesc.isArray ? { isArray: true } : {}
+      };
+    } else if (dict) {
+      type = "enum";
+      if (isStaticDictDescriptor(dict)) {
+        const displayLocale = dict.displayLocale;
+        const values = dict.keys.map((k) => {
+          const localeMap = dict.table[k];
+          const label = displayLocale !== void 0 ? localeMap?.[displayLocale] ?? void 0 : void 0;
+          return label !== void 0 ? { value: k, label } : { value: k };
+        });
+        dictBlock = { name: dict.name, static: true, values };
+      } else {
+        const labelMap = dictLabels?.[dict.name];
+        const labelMapHasEntries = labelMap !== void 0 && Object.keys(labelMap).length > 0;
+        if (labelMapHasEntries) {
+          const values = Object.entries(labelMap).map(([value, label]) => ({ value, label }));
+          dictBlock = { name: dict.name, static: false, values };
+        } else if (dict.keys !== void 0) {
+          const values = dict.keys.map((k) => {
+            const label = dict.labels?.[k];
+            return label !== void 0 ? { value: k, label } : { value: k };
+          });
+          dictBlock = { name: dict.name, static: false, values };
+        } else {
+          dictBlock = { name: dict.name, static: false };
+        }
+      }
+    } else if (lookupDesc) {
+      type = "enum";
+      const lookupLabelMap = dictLabels?.[lookupDesc.dimension];
+      const lookupLabelMapHasEntries = lookupLabelMap !== void 0 && Object.keys(lookupLabelMap).length > 0;
+      if (lookupDesc.table !== void 0) {
+        const displayLocale = lookupDesc.displayLocale;
+        const table = lookupDesc.table;
+        const values = (lookupDesc.keys ?? Object.keys(table)).map((k) => {
+          const localeMap = table[k];
+          const label = displayLocale !== void 0 ? localeMap?.[displayLocale] ?? void 0 : void 0;
+          return label !== void 0 ? { value: k, label } : { value: k };
+        });
+        dictBlock = { name: lookupDesc.dimension, static: true, values };
+      } else if (lookupLabelMapHasEntries) {
+        const values = Object.entries(lookupLabelMap).map(([value, label]) => ({ value, label }));
+        dictBlock = { name: lookupDesc.dimension, static: false, values };
+      } else if (lookupDesc.keys !== void 0) {
+        const values = lookupDesc.keys.map((k) => {
+          const label = lookupDesc.labels?.[k];
+          return label !== void 0 ? { value: k, label } : { value: k };
+        });
+        dictBlock = { name: lookupDesc.dimension, static: false, values };
+      } else {
+        dictBlock = { name: lookupDesc.dimension, static: false };
+      }
+    } else if (i18nDesc) {
+      type = "string";
+    } else if (isComputed) {
+    } else if (blobFragmentEntry !== void 0) {
+      type = "blob";
+      blobBlock = { ...blobFragmentEntry, queryable: "none" };
+    }
+    const lookupFragmentEntry = lookupFragments?.[key];
+    if (lookupFragmentEntry !== void 0) {
+      lookupBlock = {
+        ...lookupFragmentEntry.dimension !== void 0 ? { dimension: lookupFragmentEntry.dimension } : {},
+        backing: lookupFragmentEntry.backing,
+        vocabulary: lookupFragmentEntry.vocabulary,
+        key: lookupFragmentEntry.key,
+        onDelete: lookupFragmentEntry.onDelete,
+        ...lookupFragmentEntry.altKeys !== void 0 ? { altKeys: lookupFragmentEntry.altKeys } : {},
+        ...lookupFragmentEntry.present !== void 0 ? { present: lookupFragmentEntry.present } : {},
+        ...lookupFragmentEntry.sortBy !== void 0 ? { sortBy: lookupFragmentEntry.sortBy } : {},
+        ...lookupFragmentEntry.keys !== void 0 ? { keys: lookupFragmentEntry.keys } : {}
+      };
+    }
+    if (cls !== void 0) inferred.sensitivity = cls.sensitivity;
+    const channelEntry = fieldMeta?.[key];
+    const zodMeta = zod?.meta;
+    const resolved = resolveFieldMeta(key, {
+      ...channelEntry !== void 0 ? { channel: channelEntry } : {},
+      ...zodMeta !== void 0 ? { zodMeta } : {},
+      inferred
+    });
+    let i18nBlock;
+    if (i18nDesc !== void 0) {
+      const locales = i18nDesc.options.languages;
+      const densify = i18nDesc.options.densifyOnWrite;
+      i18nBlock = {
+        ...locales !== void 0 ? { locales } : {},
+        ...densify !== void 0 ? { densify } : {}
+      };
+    }
+    const widget = deriveWidget({
+      type,
+      ...resolved.semanticType !== void 0 ? { semanticType: resolved.semanticType } : {},
+      ...dictBlock !== void 0 ? { dict: dictBlock } : {},
+      ...lookupBlock !== void 0 ? { lookup: lookupBlock } : {},
+      ...blobBlock !== void 0 ? { blob: blobBlock } : {},
+      ...resolved.widget !== void 0 ? { resolvedWidget: resolved.widget } : {}
+    });
+    const editable = !isComputed && key !== "id" && blobBlock === void 0;
+    const field = {
+      key,
+      ...fieldIds?.[key] !== void 0 ? { id: fieldIds[key] } : {},
+      type,
+      optional: zod?.optional ?? false,
+      ...zod?.constraints !== void 0 ? { constraints: zod.constraints } : {},
+      label: resolved.label,
+      ...resolved.description !== void 0 ? { description: resolved.description } : {},
+      ...resolved.group !== void 0 ? { group: resolved.group } : {},
+      ...resolved.order !== void 0 ? { order: resolved.order } : {},
+      ...resolved.semanticType !== void 0 ? { semanticType: resolved.semanticType } : {},
+      ...resolved.unit !== void 0 ? { unit: resolved.unit } : {},
+      ...resolved.sensitivity !== void 0 ? { sensitivity: resolved.sensitivity } : {},
+      ...resolved.aggregate !== void 0 ? { aggregate: resolved.aggregate } : {},
+      ...resolved.aliases !== void 0 ? { aliases: resolved.aliases } : {},
+      ...resolved.displayFor !== void 0 ? { displayFor: resolved.displayFor } : {},
+      ...refBlock !== void 0 ? { ref: refBlock } : {},
+      ...moneyBlock !== void 0 ? { money: moneyBlock } : {},
+      ...dictBlock !== void 0 ? { dict: dictBlock } : {},
+      ...lookupBlock !== void 0 ? { lookup: lookupBlock } : {},
+      ...blobBlock !== void 0 ? { blob: blobBlock } : {},
+      ...isComputed ? { computed: true } : {},
+      ...i18nBlock !== void 0 ? { i18n: i18nBlock } : {},
+      widget,
+      editable,
+      ...cls !== void 0 ? {
+        classified: {
+          preset: cls.preset,
+          storage: cls.storage,
+          list: cls.list.kind === "omit" ? "omit" : cls.list.kind === "mask" ? { mask: cls.list.pattern } : { rider: cls.list.rider },
+          ...cls.equatable === true ? { equatable: true } : {}
+        }
+      } : {},
+      ...taintPosture !== void 0 ? { taint: { posture: taintPosture, forcedBy: taint?.provenance?.get(key) ?? [] } } : {}
+    };
+    fields.push(field);
+  }
+  const collectionMeta = {
+    ...meta,
+    label: meta?.label ?? humanizeFieldKey(collection)
+  };
+  return {
+    collection,
+    fields,
+    meta: collectionMeta
+  };
+}
 
 // src/kernel/via/graph.ts
 var DEFAULT_POSTURE = { encryptedAtRest: "envelope", queryable: "full", exportable: true, forgettable: false };
@@ -338,7 +712,11 @@ var ViaGraph = class {
 };
 
 export {
+  schemaFieldKeys,
+  deriveZodFields,
+  resolveDescribeFieldIds,
+  buildDescription,
   DEFAULT_POSTURE,
   ViaGraph
 };
-//# sourceMappingURL=chunk-XJP66QEN.js.map
+//# sourceMappingURL=chunk-7BE7ZDVQ.js.map