@happyvertical/smrt-fields 0.40.60 → 0.40.62

package/dist/collections/FieldUsageCounterCollection.d.ts

@@ -0,0 +1,143 @@
+import { SmrtCollection } from '@happyvertical/smrt-core';
+import { RegisteredFieldInfo } from '../field-definitions.js';
+import { FieldUsageCounter } from '../models/FieldUsageCounter.js';
+import { FieldUsageReportEntry, FieldUsageReportResult } from '../types.js';
+/**
+ * Deviation comparison: strict equality, then a JSON round-trip so structured
+ * and Date-shaped values compare by serialization. Mirrors the browser-side
+ * `fieldUsageValuesEqual` (the packaging boundary bars value imports across the
+ * subpath split — the permission-slug precedent); a node test pins the two
+ * behaviours equal.
+ */
+export declare function usageValuesEqual(a: unknown, b: unknown): boolean;
+/**
+ * Per-call bound on reported entries — the rate rail for the fire-and-forget
+ * ingestion action (the resolveBatch precedent). The browser deliberately
+ * does not impose a duplicate limit: every report is server-bounded here.
+ */
+export declare const MAX_USAGE_REPORT_ENTRIES = 100;
+/**
+ * Collection surface for {@link FieldUsageCounter} plus the batched usage
+ * ingestion action (#2051).
+ *
+ * `reportUsage` is a custom collection-scoped action (the resolveBatch
+ * mechanism — single-segment path, so the generated SvelteKit transport AND
+ * core's runtime `APIGenerator` both dispatch it). Everything else is CLOSED:
+ * no generated CRUD, no CLI, no MCP — counters are written only through this
+ * action and read only by trusted server-side code (the learning jobs).
+ */
+export declare class FieldUsageCounterCollection extends SmrtCollection<FieldUsageCounter> {
+    static readonly _itemClass: typeof FieldUsageCounter;
+    /**
+     * Record a batch of field submissions into the current UTC-day counters.
+     *
+     * Identity is AMBIENT-ONLY (the resolveBatch posture): the tenant AND the
+     * user come exclusively from the tenant context established by the app's
+     * auth hook — the request body cannot attribute usage to another tenant or
+     * user. Both are REQUIRED and the call fails closed without them (#2047
+     * round-3 posture):
+     *
+     * - No ambient tenant ⇒ the report is unattributable.
+     * - No ambient USER ⇒ the caller is an unauthenticated principal (a
+     *   deployment that resolves the tenant from host/header alone). Such
+     *   callers could otherwise inflate counts and histograms without bound
+     *   (the batch cap is per call), and `distinctUsers` — the promote signal —
+     *   is meaningless without a principal. Consequence, accepted deliberately:
+     *   ANONYMOUS/PUBLIC FORMS DO NOT CONTRIBUTE USAGE. The learning loop is
+     *   for authenticated org users.
+     *
+     * Any authenticated in-tenant principal may report (no manage slug needed).
+     * A durable receipt admits at most one `(tenant, user, object, field, UTC
+     * day)` contribution, and the batch stays bounded per call
+     * ({@link MAX_USAGE_REPORT_ENTRIES}).
+     *
+     * Server-side derivation (the client is never the authority):
+     * - Fields are validated against the live `ObjectRegistry`; unknown or
+     *   non-usage-addressable entries (system, relationship pseudo-fields, STI
+     *   meta storage, transient) are DROPPED and counted, never failing the
+     *   batch (stale clients after a redeploy are expected).
+     * - Sensitivity comes from BOTH `field.sensitive` and `field._meta.sensitive`
+     *   (and `readPermission` in both places): such fields are recorded
+     *   COUNT-ONLY — their values are never persisted anywhere in usage data,
+     *   default-matching or not.
+     * - DEVIATION (`setCount`, distinct users) is decided by comparing the
+     *   submitted value against the default RESOLVED HERE for the calling
+     *   identity — never against a client claim. Every accepted entry also
+     *   increments `submissionCount`, the dominance denominator.
+     * - Values are histogrammed only for low-cardinality field types
+     *   (`boolean`, `foreignKey`, `crossPackageRef`) with type-checked samples;
+     *   free text is never histogrammed.
+     *
+     * Bounded trust in `matchedDefault`: an entry may omit `value` entirely
+     * (`collectFieldUsageEntries({ includeValues: false })` — apps that prefer
+     * no value transit). Only then is the entry's `matchedDefault` flag read, to
+     * decide the deviation bit alone. It can never create a histogram entry,
+     * never bypass the count-only rail, and never manufacture distinct users
+     * beyond the caller's own id. The once-per-field/day receipt means a lying
+     * client gets only one such contribution, so repeated POSTs cannot inflate
+     * thresholds or steer a `default` suggestion.
+     */
+    reportUsage(options?: {
+        entries?: FieldUsageReportEntry[];
+    }): Promise<FieldUsageReportResult>;
+    /**
+     * The defaults the CALLER's forms would have prefilled — the deviation
+     * authority. Resolved for the ambient `(tenant, user)` identity (the
+     * resolver's own TTL cache keeps repeat batches cheap).
+     *
+     * Ingestion is fire-and-forget, so a stored-layer read failure degrades to
+     * the CODE-SEED-only resolution (no db) rather than failing the request;
+     * `null` (both attempts failed) makes the caller drop the group.
+     */
+    private resolveDefaultsForCaller;
+    /**
+     * Counter rows within a period window (inclusive bounds, lexicographic ISO
+     * day comparison), optionally restricted to one tenant — the read the
+     * suggestion-generation job consumes.
+     */
+    listWindow(options: {
+        fromPeriod: string;
+        toPeriod?: string;
+        tenantId?: string | null;
+    }): Promise<FieldUsageCounter[]>;
+    /**
+     * Idempotent read-modify-write merge into the deterministic day bucket.
+     * Counters are approximate by design: concurrent cross-process merges may
+     * lose an increment (documented on the model), while the deterministic id
+     * plus the natural-key unique index keep concurrent creates converging on
+     * one row.
+     */
+    private mergeIntoBucket;
+}
+/**
+ * Deterministic bucket row id (the TenantUsageMetric `recordUsage` precedent):
+ * SHA-256 over the natural key, formatted as a v5-style UUID so the id column
+ * stays native UUID on PostgreSQL/DuckDB.
+ */
+export declare function fieldUsageCounterId(tenantId: string, objectRef: string, fieldName: string, period: string): Promise<string>;
+/** Deterministic receipt id for the durable once-per-day contribution rule. */
+export declare function fieldUsageReportReceiptId(tenantId: string, userId: string, objectRef: string, fieldName: string, period: string): Promise<string>;
+/**
+ * Histogram eligibility (#2051 pin): ONLY low-cardinality field types —
+ * `boolean` and reference ids (`foreignKey` / `crossPackageRef`). Free text
+ * is NEVER histogrammed, even when non-sensitive (PII risk); numeric,
+ * datetime, and json fields are count-only too.
+ */
+export declare function isHistogramEligibleField(field: RegisteredFieldInfo): boolean;
+/**
+ * Serialize one sample into a histogram key, type-checked against the field:
+ * booleans must be real booleans (`'true'` / `'false'` keys); reference ids
+ * must be STORABLE ids for the field — `isStorableReferenceId` applies the same
+ * native-UUID / `idType: 'text'` rule stored defaults are held to, within the
+ * bounded key length. Anything else is skipped (the submission still counts —
+ * count-only for that sample).
+ *
+ * The reference check is load-bearing, not cosmetic: recording an unstorable
+ * id would let an authenticated caller poison a histogram, win dominance with
+ * it, and produce a `default` suggestion whose write is then rejected by the
+ * same rule — turning a bad sample into a stuck generation candidate.
+ */
+export declare function serializeHistogramSample(field: RegisteredFieldInfo, value: unknown): string | null;
+/** Decode a histogram key back into the typed value it was recorded from. */
+export declare function decodeHistogramKey(field: RegisteredFieldInfo, key: string): unknown;
+//# sourceMappingURL=FieldUsageCounterCollection.d.ts.map

package/dist/collections/FieldUsageCounterCollection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FieldUsageCounterCollection.d.ts","sourceRoot":"","sources":["../../src/collections/FieldUsageCounterCollection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAQ,MAAM,0BAA0B,CAAC;AAMhE,OAAO,EAOL,KAAK,mBAAmB,EACzB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,iBAAiB,EAGlB,MAAM,gCAAgC,CAAC;AAExC,OAAO,KAAK,EACV,qBAAqB,EACrB,sBAAsB,EAEvB,MAAM,aAAa,CAAC;AAErB;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAShE;AAED;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,MAAM,CAAC;AAa5C;;;;;;;;;GASG;AACH,qBAsBa,2BAA4B,SAAQ,cAAc,CAAC,iBAAiB,CAAC;IAChF,MAAM,CAAC,QAAQ,CAAC,UAAU,2BAAqB;IAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgDG;IACG,WAAW,CACf,OAAO,GAAE;QAAE,OAAO,CAAC,EAAE,qBAAqB,EAAE,CAAA;KAAO,GAClD,OAAO,CAAC,sBAAsB,CAAC;IAkJlC;;;;;;;;OAQG;YACW,wBAAwB;IA4BtC;;;;OAIG;IACG,UAAU,CAAC,OAAO,EAAE;QACxB,UAAU,EAAE,MAAM,CAAC;QACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;KAC1B,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC;IAahC;;;;;;OAMG;YACW,eAAe;CA8C9B;AA6CD;;;;GAIG;AACH,wBAAsB,mBAAmB,CACvC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,MAAM,CAAC,CAQjB;AAED,+EAA+E;AAC/E,wBAAsB,yBAAyB,CAC7C,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,MAAM,CAAC,CASjB;AAiBD;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAM5E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,mBAAmB,EAC1B,KAAK,EAAE,OAAO,GACb,MAAM,GAAG,IAAI,CAWf;AAED,6EAA6E;AAC7E,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,mBAAmB,EAC1B,GAAG,EAAE,MAAM,GACV,OAAO,CAKT"}

package/dist/deterministic-id.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Deterministic row ids for this package's idempotent writes (the
+ * `TenantUsageMetric.recordUsage` precedent).
+ *
+ * A leaf module (no package-internal imports) so both consumers — usage counter
+ * buckets and the global learning schedules — share one implementation. The
+ * output is formatted as a v5-shaped UUID so id columns stay native UUID on
+ * PostgreSQL/DuckDB.
+ */
+/**
+ * SHA-256 over the namespaced parts, formatted as a v5-style UUID.
+ *
+ * The same parts always produce the same id, which is what turns
+ * "check then create" into a race-free write: concurrent creators converge on
+ * one primary key instead of inserting near-duplicate rows.
+ */
+export declare function deterministicFieldsUuid(parts: readonly string[]): Promise<string>;
+//# sourceMappingURL=deterministic-id.d.ts.map

package/dist/deterministic-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deterministic-id.d.ts","sourceRoot":"","sources":["../src/deterministic-id.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;;;GAMG;AACH,wBAAsB,uBAAuB,CAC3C,KAAK,EAAE,SAAS,MAAM,EAAE,GACvB,OAAO,CAAC,MAAM,CAAC,CAgBjB"}

package/dist/field-definitions.d.ts

@@ -0,0 +1,85 @@
+import { FieldUIHints, ObjectRegistry } from '@happyvertical/smrt-core';
+import { FieldPolicyDelta, FieldPolicyVisibility } from './types.js';
+/**
+ * Field map for one object, keyed by field name (includes inherited fields).
+ * Derived structurally from the PUBLIC `ObjectRegistry.getAllFields` return
+ * type — core does not export its internal `RegisteredField` name.
+ */
+export type FieldDefinitionMap = Awaited<ReturnType<typeof ObjectRegistry.getAllFields>>;
+/** One field's registered metadata, as returned by `getAllFields`. */
+export type RegisteredFieldInfo = FieldDefinitionMap extends Map<string, infer F> ? F : never;
+/**
+ * Resolve `objectRef` (qualified `@package/name:ClassName`) against the live
+ * registry, throwing a descriptive error when the class is unknown.
+ */
+export declare function requireRegisteredObject(objectRef: string): void;
+/** Load the full (inherited) field map for a registered objectRef. */
+export declare function getObjectFieldMap(objectRef: string): Promise<FieldDefinitionMap>;
+/**
+ * Narrow a manifest `_meta.ui` bag to the known {@link FieldUIHints} keys with
+ * their expected primitive types, dropping junk (mirrors the sanitization the
+ * web emission applies in core's `web-collections.ts`).
+ */
+export declare function sanitizeFieldUIHints(value: unknown): FieldUIHints | undefined;
+/** Security rail: `sensitive` may live top-level or under `_meta` (STI merges). */
+export declare function isSensitiveField(field: RegisteredFieldInfo): boolean;
+/** Security rail: `readPermission` may live top-level or under `_meta`. */
+export declare function getFieldReadPermission(field: RegisteredFieldInfo): string | undefined;
+export declare function isTransientField(field: RegisteredFieldInfo): boolean;
+/**
+ * True when a registered field can receive a policy row.  Keep this shared by
+ * the resolver and the catalog audit: otherwise a row that never resolves can
+ * accidentally be presented as an editable setting.
+ */
+export declare function isPolicyAddressableField(field: RegisteredFieldInfo): boolean;
+/**
+ * A field is required when flagged required and not explicitly nullable.
+ *
+ * `nullable` is read from BOTH the top level and `_meta` for the same reason
+ * `sensitive`/`readPermission`/`transient` are: registrations reach the
+ * registry through several paths (decorator, manifest, STI merge) and land the
+ * flag in either place. Checking only one side made the pair asymmetric —
+ * `required` was read from both while `nullable` was read from one.
+ */
+export declare function isRequiredField(field: RegisteredFieldInfo): boolean;
+/** The manifest/code default for a field, boxed; `undefined` when none. */
+export declare function getCodeDefault(field: RegisteredFieldInfo): {
+    value: unknown;
+} | undefined;
+/**
+ * A resolved default satisfies the required-field invariant only when it is a
+ * value a form could actually submit: explicit `null` and the empty string do
+ * not count (a required text field "defaulting" to `''` is still unfilled).
+ */
+export declare function isUsableRequiredDefault(defaultBox: {
+    value: unknown;
+} | undefined): boolean;
+/**
+ * Compute the code-seed visibility for every field of an object using the
+ * cold-start rule (#2046): with no `ui.basic` markers anywhere on the object,
+ * every field is `basic`; once any field is marked `basic: true`, unmarked
+ * fields default to `advanced` (and an explicit `basic: false` is always
+ * `advanced`).
+ */
+export declare function buildCodeSeedVisibility(fields: FieldDefinitionMap): Map<string, FieldPolicyVisibility>;
+/** Code-seed delta for one field (visibility supplied by the cold-start pass). */
+export declare function buildCodeSeedDelta(field: RegisteredFieldInfo, visibility: FieldPolicyVisibility): FieldPolicyDelta;
+/** Code-seed grouping key (`ui.group`) — not overridable by stored rows. */
+export declare function getCodeSeedGroup(field: RegisteredFieldInfo): string | null;
+/**
+ * True when a reference identifier can be stored in the field's backing
+ * column. Native UUID columns accept UUIDs only; `idType: 'text'` opts into
+ * arbitrary non-empty string identifiers. Shared by policy defaults and the
+ * usage histogram so a poisoned sample can never become an unwriteable
+ * suggestion.
+ */
+export declare function isStorableReferenceId(field: RegisteredFieldInfo, value: unknown): value is string;
+/**
+ * Type-check a parsed default value against the manifest field type.
+ *
+ * Explicit `null` is allowed only for optional fields (a required field with a
+ * null default has no usable default). Unsupported field types reject defaults
+ * outright (fail closed).
+ */
+export declare function assertDefaultValueMatchesFieldType(objectRef: string, fieldName: string, field: RegisteredFieldInfo, value: unknown): void;
+//# sourceMappingURL=field-definitions.d.ts.map

package/dist/field-definitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"field-definitions.d.ts","sourceRoot":"","sources":["../src/field-definitions.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAE1E;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,OAAO,CACtC,UAAU,CAAC,OAAO,cAAc,CAAC,YAAY,CAAC,CAC/C,CAAC;AAEF,sEAAsE;AACtE,MAAM,MAAM,mBAAmB,GAC7B,kBAAkB,SAAS,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAE9D;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAa/D;AAED,sEAAsE;AACtE,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,kBAAkB,CAAC,CAG7B;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,YAAY,GAAG,SAAS,CAc7E;AAED,mFAAmF;AACnF,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAEpE;AAED,2EAA2E;AAC3E,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,mBAAmB,GACzB,MAAM,GAAG,SAAS,CAMpB;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAEpE;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAO5E;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAKnE;AAED,2EAA2E;AAC3E,wBAAgB,cAAc,CAC5B,KAAK,EAAE,mBAAmB,GACzB;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,CAQhC;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,GACzC,OAAO,CAKT;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,kBAAkB,GACzB,GAAG,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAuBpC;AAED,kFAAkF;AAClF,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,mBAAmB,EAC1B,UAAU,EAAE,qBAAqB,GAChC,gBAAgB,CAiBlB;AAED,4EAA4E;AAC5E,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,mBAAmB,GAAG,MAAM,GAAG,IAAI,CAE1E;AAUD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,mBAAmB,EAC1B,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,MAAM,CAGjB;AAED;;;;;;GAMG;AACH,wBAAgB,kCAAkC,CAChD,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,mBAAmB,EAC1B,KAAK,EAAE,OAAO,GACb,IAAI,CAsEN"}

package/dist/field-policy-resolver.d.ts

@@ -0,0 +1,46 @@
+import { ExplainedObjectFieldPolicy, ResolvedObjectFieldPolicy, ResolveFieldPolicyOptions } from './types.js';
+/**
+ * Resolve the merged field policy for `objectRef` in the given
+ * `(tenantId, userId)` context: code seed → app rows → tenant rows (hierarchy
+ * walk root → leaf) → user rows. Defaults AND visibility both resolve through
+ * the user tier.
+ *
+ * Results are cached per `(database, objectRef, tenantId, userId)` with a
+ * short TTL; `FieldPolicy.save()`/`.delete()` invalidate the object's entries.
+ */
+export declare function resolveFieldPolicy(objectRef: string, options?: ResolveFieldPolicyOptions): Promise<ResolvedObjectFieldPolicy>;
+/**
+ * The tenant ids whose rows participate in precedence for a tenant, root to
+ * leaf. Catalog code uses this instead of reimplementing inheritance-break
+ * handling when it decides whether an inherited override is customized.
+ */
+export declare function resolveSurvivingTenantChainIds(tenantId: string, options?: ResolveFieldPolicyOptions): Promise<string[]>;
+/**
+ * Explain variant: the merged result plus ordered per-layer contributions for
+ * each field, so the gear UI (#2049, "shows inherited base") and the control
+ * panel (#2050, effective-value-per-layer) never re-derive precedence.
+ *
+ * A user-layer row suppressed by an effective org lock is omitted from the
+ * layer list too — the listed layers always reproduce the merged result.
+ */
+export declare function resolveFieldPolicyExplained(objectRef: string, options?: ResolveFieldPolicyOptions): Promise<ExplainedObjectFieldPolicy>;
+/**
+ * Whether an import failure means `@happyvertical/smrt-users` is simply not
+ * installed (→ flat-tenant fallback) rather than installed-but-broken
+ * (→ rethrow, surfacing the problem instead of silently losing ancestor
+ * locks/defaults).
+ *
+ * The decision is made on the missing-module TARGET parsed from Node's
+ * `Cannot find package/module '<specifier>'` message (walking the full
+ * `cause` chain): only a target that IS smrt-users (or one of its subpaths)
+ * counts. A transitive failure INSIDE an installed smrt-users names the
+ * other package as the target — with the users path merely appearing as the
+ * importer — and therefore rethrows. `importWorkspaceModule`'s own
+ * source-fallback wrapper ("Failed to load @happyvertical/smrt-users for
+ * ...") is also accepted: it is thrown only when the users package itself
+ * cannot be located.
+ *
+ * Exported for direct testing; not re-exported from the package index.
+ */
+export declare function isMissingUsersDependency(error: unknown): boolean;
+//# sourceMappingURL=field-policy-resolver.d.ts.map

package/dist/field-policy-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"field-policy-resolver.d.ts","sourceRoot":"","sources":["../src/field-policy-resolver.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EACV,0BAA0B,EAQ1B,yBAAyB,EACzB,yBAAyB,EAE1B,MAAM,YAAY,CAAC;AAYpB;;;;;;;;GAQG;AACH,wBAAsB,kBAAkB,CACtC,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,yBAA8B,GACtC,OAAO,CAAC,yBAAyB,CAAC,CAGpC;AAED;;;;GAIG;AACH,wBAAsB,8BAA8B,CAClD,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,yBAA8B,GACtC,OAAO,CAAC,MAAM,EAAE,CAAC,CAInB;AAED;;;;;;;GAOG;AACH,wBAAsB,2BAA2B,CAC/C,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,yBAA8B,GACtC,OAAO,CAAC,0BAA0B,CAAC,CA0JrC;AA0MD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAsBhE"}