@vertz/ui 0.2.12 → 0.2.13

package/dist/shared/chunk-hw67ckr3.js

@@ -0,0 +1,1212 @@
+import {
+  isNavPrefetchActive
+} from "./chunk-jrtrk5z4.js";
+import {
+  getAdapter,
+  isRenderNode
+} from "./chunk-h89w580h.js";
+import {
+  _tryOnCleanup,
+  batch,
+  computed,
+  domEffect,
+  getSSRContext,
+  lifecycleEffect,
+  popScope,
+  pushScope,
+  runCleanups,
+  setReadValueCallback,
+  signal,
+  untrack
+} from "./chunk-8hsz5y4a.js";
+
+// src/query/cache.ts
+class MemoryCache {
+  _store = new Map;
+  get(key) {
+    return this._store.get(key);
+  }
+  set(key, value) {
+    this._store.set(key, value);
+  }
+  delete(key) {
+    this._store.delete(key);
+  }
+  clear() {
+    this._store.clear();
+  }
+}
+
+// src/query/invalidate.ts
+var registry = new Set;
+function registerActiveQuery(entityMeta, refetch) {
+  const registration = { entityMeta, refetch };
+  registry.add(registration);
+  return () => registry.delete(registration);
+}
+function invalidate(descriptor) {
+  const meta = descriptor._entity;
+  if (!meta)
+    return;
+  if (meta.kind === "get" && !meta.id)
+    return;
+  for (const reg of [...registry]) {
+    if (reg.entityMeta.entityType !== meta.entityType)
+      continue;
+    if (reg.entityMeta.kind !== meta.kind)
+      continue;
+    if (meta.kind === "get" && reg.entityMeta.id !== meta.id)
+      continue;
+    reg.refetch();
+  }
+}
+
+// src/query/key-derivation.ts
+function deriveKey(thunk) {
+  return `__q:${hashString(thunk.toString())}`;
+}
+function hashString(str) {
+  let hash = 5381;
+  for (let i = 0;i < str.length; i++) {
+    hash = hash * 33 ^ str.charCodeAt(i);
+  }
+  return (hash >>> 0).toString(36);
+}
+
+// src/store/relation-registry.ts
+var registry2 = new Map;
+function registerRelationSchema(entityType, schema) {
+  registry2.set(entityType, Object.freeze(schema));
+}
+function getRelationSchema(entityType) {
+  return registry2.get(entityType);
+}
+function resetRelationSchemas_TEST_ONLY() {
+  registry2.clear();
+}
+
+// src/store/merge.ts
+function shallowMerge(existing, incoming) {
+  const result = { ...existing };
+  for (const key of Object.keys(incoming)) {
+    const value = incoming[key];
+    if (value !== undefined) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function shallowEqual(a, b) {
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) {
+    return false;
+  }
+  for (const key of keysA) {
+    const valA = a[key];
+    const valB = b[key];
+    if (valA !== valB) {
+      if (Array.isArray(valA) && Array.isArray(valB)) {
+        if (valA.length !== valB.length)
+          return false;
+        for (let i = 0;i < valA.length; i++) {
+          if (valA[i] !== valB[i])
+            return false;
+        }
+        continue;
+      }
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/store/normalize.ts
+function normalizeEntity(entityType, data, visiting) {
+  const schema = getRelationSchema(entityType);
+  if (!schema) {
+    return { normalized: data, extracted: new Map };
+  }
+  const extracted = new Map;
+  const normalized = { ...data };
+  const visitKey = `${entityType}/${data.id}`;
+  const visit = visiting ?? new Set;
+  if (visit.has(visitKey)) {
+    return { normalized: data, extracted };
+  }
+  visit.add(visitKey);
+  for (const [field, rel] of Object.entries(schema)) {
+    const value = data[field];
+    if (value == null)
+      continue;
+    if (rel.type === "one") {
+      if (typeof value === "string")
+        continue;
+      if (typeof value !== "object" || Array.isArray(value)) {
+        console.warn(`[vertz] ${entityType}.${field}: expected object or string for 'one' relation, got ${typeof value}`);
+        continue;
+      }
+      if (typeof value === "object" && !Array.isArray(value)) {
+        const nested = value;
+        if (typeof nested.id !== "string")
+          continue;
+        const nestedVisitKey = `${rel.entity}/${nested.id}`;
+        if (visit.has(nestedVisitKey)) {
+          normalized[field] = nested.id;
+          continue;
+        }
+        const nestedResult = normalizeEntity(rel.entity, nested, visit);
+        const list = extracted.get(rel.entity) ?? [];
+        list.push(nestedResult.normalized);
+        extracted.set(rel.entity, list);
+        for (const [type, items] of nestedResult.extracted) {
+          const existing = extracted.get(type) ?? [];
+          existing.push(...items);
+          extracted.set(type, existing);
+        }
+        normalized[field] = nested.id;
+      }
+    } else if (rel.type === "many") {
+      if (!Array.isArray(value)) {
+        console.warn(`[vertz] ${entityType}.${field}: expected array for 'many' relation, got ${typeof value}`);
+        continue;
+      }
+      const ids = [];
+      for (const element of value) {
+        if (typeof element === "string") {
+          ids.push(element);
+        } else if (typeof element === "object" && element != null && typeof element.id === "string") {
+          const nested = element;
+          const nestedVisitKey = `${rel.entity}/${nested.id}`;
+          if (visit.has(nestedVisitKey)) {
+            ids.push(nested.id);
+            continue;
+          }
+          const nestedResult = normalizeEntity(rel.entity, nested, visit);
+          const list = extracted.get(rel.entity) ?? [];
+          list.push(nestedResult.normalized);
+          extracted.set(rel.entity, list);
+          for (const [type, items] of nestedResult.extracted) {
+            const existing = extracted.get(type) ?? [];
+            existing.push(...items);
+            extracted.set(type, existing);
+          }
+          ids.push(nested.id);
+        } else {
+          ids.push(element);
+        }
+      }
+      normalized[field] = ids;
+    }
+  }
+  return { normalized, extracted };
+}
+
+// src/store/query-result-index.ts
+class QueryResultIndex {
+  _indices = new Map;
+  set(queryKey, ids) {
+    this._indices.set(queryKey, ids);
+  }
+  get(queryKey) {
+    return this._indices.get(queryKey);
+  }
+  removeEntity(entityId) {
+    for (const [queryKey, ids] of this._indices.entries()) {
+      const filtered = ids.filter((id) => id !== entityId);
+      if (filtered.length !== ids.length) {
+        this._indices.set(queryKey, filtered);
+      }
+    }
+  }
+  clear(queryKey) {
+    this._indices.delete(queryKey);
+  }
+  snapshotEntity(entityId) {
+    const result = new Map;
+    for (const [queryKey, ids] of this._indices.entries()) {
+      if (ids.includes(entityId)) {
+        result.set(queryKey, [...ids]);
+      }
+    }
+    return result;
+  }
+  keys() {
+    return Array.from(this._indices.keys());
+  }
+}
+
+// src/store/entity-store.ts
+class EntityStore {
+  _entities = new Map;
+  _typeListeners = new Map;
+  _queryIndices = new QueryResultIndex;
+  get queryIndices() {
+    return this._queryIndices;
+  }
+  constructor(options) {
+    if (options?.initialData) {
+      this.hydrate(options.initialData);
+    }
+  }
+  get(type, id) {
+    const typeMap = this._entities.get(type);
+    const entry = typeMap?.get(id);
+    if (entry) {
+      return entry.signal;
+    }
+    const sig = signal(undefined);
+    const newEntry = {
+      signal: sig,
+      base: {},
+      layers: new Map,
+      refCount: 0,
+      orphanedAt: null
+    };
+    this._getOrCreateTypeMap(type).set(id, newEntry);
+    return sig;
+  }
+  getMany(type, ids) {
+    return computed(() => ids.map((id) => this.get(type, id).value));
+  }
+  merge(type, data) {
+    const items = Array.isArray(data) ? data : [data];
+    if (items.length === 0) {
+      return;
+    }
+    batch(() => {
+      for (const item of items) {
+        const { normalized, extracted } = normalizeEntity(type, item);
+        for (const [nestedType, nestedItems] of extracted) {
+          for (const nestedItem of nestedItems) {
+            this._mergeOne(nestedType, nestedItem);
+          }
+        }
+        this._mergeOne(type, normalized);
+      }
+    });
+  }
+  remove(type, id) {
+    const typeMap = this._entities.get(type);
+    if (!typeMap?.has(id)) {
+      return;
+    }
+    const entry = typeMap.get(id);
+    if (entry) {
+      entry.signal.value = undefined;
+    }
+    typeMap.delete(id);
+    this._queryIndices.removeEntity(id);
+    this._notifyTypeChange(type);
+  }
+  onTypeChange(type, callback) {
+    const listeners = this._getOrCreateListeners(type);
+    listeners.add(callback);
+    return () => {
+      listeners.delete(callback);
+    };
+  }
+  has(type, id) {
+    const typeMap = this._entities.get(type);
+    if (!typeMap?.has(id)) {
+      return false;
+    }
+    const entry = typeMap.get(id);
+    return entry?.signal.peek() !== undefined;
+  }
+  size(type) {
+    const typeMap = this._entities.get(type);
+    if (!typeMap) {
+      return 0;
+    }
+    let count = 0;
+    for (const entry of typeMap.values()) {
+      if (entry.signal.peek() !== undefined) {
+        count++;
+      }
+    }
+    return count;
+  }
+  dehydrate() {
+    const entities = {};
+    for (const [type, typeMap] of this._entities.entries()) {
+      const typeEntities = {};
+      for (const [id, entry] of typeMap.entries()) {
+        if (entry.base !== undefined) {
+          typeEntities[id] = entry.base;
+        }
+      }
+      if (Object.keys(typeEntities).length > 0) {
+        entities[type] = typeEntities;
+      }
+    }
+    const queries = {};
+    for (const queryKey of this._queryIndices.keys()) {
+      const ids = this._queryIndices.get(queryKey);
+      if (ids) {
+        queries[queryKey] = { ids };
+      }
+    }
+    return {
+      entities,
+      ...Object.keys(queries).length > 0 ? { queries } : {}
+    };
+  }
+  hydrate(data) {
+    for (const [type, typeEntities] of Object.entries(data.entities)) {
+      const entities = Object.values(typeEntities).map((entity) => entity);
+      this.merge(type, entities);
+    }
+    if (data.queries) {
+      for (const [queryKey, queryData] of Object.entries(data.queries)) {
+        this._queryIndices.set(queryKey, queryData.ids);
+      }
+    }
+  }
+  applyLayer(type, id, mutationId, patch) {
+    const entry = this._entities.get(type)?.get(id);
+    if (!entry)
+      return;
+    entry.layers.set(mutationId, patch);
+    this._recomputeVisible(entry);
+  }
+  addRef(type, id) {
+    const entry = this._entities.get(type)?.get(id);
+    if (!entry)
+      return;
+    entry.refCount++;
+    entry.orphanedAt = null;
+  }
+  removeRef(type, id) {
+    const entry = this._entities.get(type)?.get(id);
+    if (!entry)
+      return;
+    if (entry.refCount > 0) {
+      entry.refCount--;
+    }
+    if (entry.refCount === 0) {
+      entry.orphanedAt = Date.now();
+    }
+  }
+  evictOrphans(maxAge = 300000) {
+    const now = Date.now();
+    let count = 0;
+    for (const [_type, typeMap] of this._entities) {
+      for (const [id, entry] of typeMap) {
+        if (entry.refCount === 0 && entry.orphanedAt !== null && now - entry.orphanedAt >= maxAge && entry.layers.size === 0) {
+          entry.signal.value = undefined;
+          typeMap.delete(id);
+          this._queryIndices.removeEntity(id);
+          count++;
+        }
+      }
+    }
+    return count;
+  }
+  inspect(type, id) {
+    const entry = this._entities.get(type)?.get(id);
+    if (!entry)
+      return;
+    return {
+      base: entry.base,
+      layers: entry.layers,
+      visible: entry.signal.peek(),
+      refCount: entry.refCount,
+      orphanedAt: entry.orphanedAt
+    };
+  }
+  rollbackLayer(type, id, mutationId) {
+    const entry = this._entities.get(type)?.get(id);
+    if (!entry)
+      return;
+    entry.layers.delete(mutationId);
+    this._recomputeVisible(entry);
+  }
+  removeOptimistic(type, id, _mutationId) {
+    this.remove(type, id);
+  }
+  restoreOptimistic(type, _id, _mutationId, entitySnapshot, indexSnapshot) {
+    if (entitySnapshot) {
+      this.merge(type, entitySnapshot);
+    }
+    for (const [queryKey, ids] of indexSnapshot) {
+      this._queryIndices.set(queryKey, ids);
+    }
+  }
+  commitLayer(type, id, mutationId, serverData) {
+    const entry = this._entities.get(type)?.get(id);
+    if (!entry)
+      return;
+    const { normalized, extracted } = normalizeEntity(type, serverData);
+    for (const [nestedType, nestedItems] of extracted) {
+      for (const nestedItem of nestedItems) {
+        this._mergeOne(nestedType, nestedItem);
+      }
+    }
+    entry.base = normalized;
+    entry.layers.delete(mutationId);
+    this._recomputeVisible(entry);
+  }
+  _mergeOne(type, item) {
+    const id = item.id;
+    const typeMap = this._entities.get(type);
+    const entry = typeMap?.get(id);
+    if (entry) {
+      const mergedBase = shallowMerge(entry.base, item);
+      if (!shallowEqual(entry.base, mergedBase)) {
+        entry.base = mergedBase;
+        this._recomputeVisible(entry);
+      }
+    } else {
+      const newSignal = signal(item);
+      const newEntry = {
+        signal: newSignal,
+        base: item,
+        layers: new Map,
+        refCount: 0,
+        orphanedAt: null
+      };
+      this._getOrCreateTypeMap(type).set(id, newEntry);
+      this._notifyTypeChange(type);
+    }
+  }
+  _recomputeVisible(entry) {
+    let visible = { ...entry.base };
+    for (const patch of entry.layers.values()) {
+      visible = shallowMerge(visible, patch);
+    }
+    const current = entry.signal.peek();
+    if (current == null || !shallowEqual(current, visible)) {
+      untrack(() => {
+        entry.signal.value = visible;
+      });
+    }
+  }
+  _getOrCreateTypeMap(type) {
+    let typeMap = this._entities.get(type);
+    if (!typeMap) {
+      typeMap = new Map;
+      this._entities.set(type, typeMap);
+    }
+    return typeMap;
+  }
+  _getOrCreateListeners(type) {
+    let listeners = this._typeListeners.get(type);
+    if (!listeners) {
+      listeners = new Set;
+      this._typeListeners.set(type, listeners);
+    }
+    return listeners;
+  }
+  _notifyTypeChange(type) {
+    const listeners = this._typeListeners.get(type);
+    if (listeners) {
+      for (const callback of listeners) {
+        callback();
+      }
+    }
+  }
+}
+
+// src/store/query-envelope-store.ts
+class QueryEnvelopeStore {
+  _envelopes = new Map;
+  get(queryKey) {
+    return this._envelopes.get(queryKey);
+  }
+  set(queryKey, envelope) {
+    this._envelopes.set(queryKey, envelope);
+  }
+  clear() {
+    this._envelopes.clear();
+  }
+}
+
+// src/store/entity-store-singleton.ts
+var _store = new EntityStore;
+var _envelopeStore = new QueryEnvelopeStore;
+function getEntityStore() {
+  const ctx = getSSRContext();
+  if (ctx)
+    return ctx.entityStore;
+  return _store;
+}
+function getQueryEnvelopeStore() {
+  const ctx = getSSRContext();
+  if (ctx)
+    return ctx.envelopeStore;
+  return _envelopeStore;
+}
+
+// src/query/query.ts
+import {
+  isQueryDescriptor
+} from "@vertz/fetch";
+
+// src/store/mutation-event-bus.ts
+function createMutationEventBus() {
+  const listeners = new Map;
+  return {
+    subscribe(entityType, callback) {
+      let set = listeners.get(entityType);
+      if (!set) {
+        set = new Set;
+        listeners.set(entityType, set);
+      }
+      set.add(callback);
+      return () => set?.delete(callback);
+    },
+    emit(entityType) {
+      const set = listeners.get(entityType);
+      if (set) {
+        for (const cb of [...set])
+          cb();
+      }
+    },
+    clear() {
+      listeners.clear();
+    }
+  };
+}
+
+// src/store/mutation-event-bus-singleton.ts
+var _bus = createMutationEventBus();
+function getMutationEventBus() {
+  return _bus;
+}
+
+// src/store/resolve.ts
+function resolveReferences(entity, entityType, store, visiting, refKeys) {
+  const schema = getRelationSchema(entityType);
+  if (!schema) {
+    if (refKeys && typeof entity.id === "string") {
+      refKeys.add(`${entityType}:${entity.id}`);
+    }
+    return entity;
+  }
+  const visitKey = `${entityType}/${entity.id}`;
+  const visit = visiting ?? new Set;
+  if (visit.has(visitKey)) {
+    return entity;
+  }
+  visit.add(visitKey);
+  if (refKeys && typeof entity.id === "string") {
+    refKeys.add(`${entityType}:${entity.id}`);
+  }
+  const resolved = { ...entity };
+  for (const [field, rel] of Object.entries(schema)) {
+    const value = entity[field];
+    if (value == null)
+      continue;
+    if (rel.type === "one") {
+      if (typeof value === "string") {
+        const referenced = store.get(rel.entity, value).value;
+        if (referenced) {
+          resolved[field] = resolveReferences(referenced, rel.entity, store, visit, refKeys);
+        } else {
+          resolved[field] = null;
+        }
+      } else if (typeof value === "object" && !Array.isArray(value)) {
+        resolved[field] = value;
+      }
+    } else if (rel.type === "many") {
+      if (Array.isArray(value)) {
+        const items = [];
+        for (const element of value) {
+          if (typeof element === "string") {
+            const referenced = store.get(rel.entity, element).value;
+            if (referenced) {
+              items.push(resolveReferences(referenced, rel.entity, store, visit, refKeys));
+            }
+          } else if (typeof element === "object" && element != null) {
+            items.push(element);
+          }
+        }
+        resolved[field] = items;
+      }
+    }
+  }
+  return resolved;
+}
+
+// src/query/ssr-hydration.ts
+function hydrateQueryFromSSR(key, resolve, options) {
+  const ssrData = globalThis.__VERTZ_SSR_DATA__;
+  if (!ssrData)
+    return null;
+  const persistent = options?.persistent ?? false;
+  const existing = ssrData.find((entry) => entry.key === key);
+  if (existing) {
+    resolve(existing.data);
+    if (!persistent)
+      return () => {};
+  }
+  const handler = (event) => {
+    const detail = event.detail;
+    if (detail.key === key) {
+      resolve(detail.data);
+      if (!persistent) {
+        document.removeEventListener("vertz:ssr-data", handler);
+      }
+    }
+  };
+  document.addEventListener("vertz:ssr-data", handler);
+  return () => {
+    document.removeEventListener("vertz:ssr-data", handler);
+  };
+}
+
+// src/query/query.ts
+function isSSR() {
+  return getSSRContext() !== undefined;
+}
+function getGlobalSSRTimeout() {
+  return getSSRContext()?.globalSSRTimeout;
+}
+var defaultCache = new MemoryCache;
+var inflight = new Map;
+function getDefaultCache() {
+  const ctx = getSSRContext();
+  if (ctx)
+    return ctx.queryCache;
+  return defaultCache;
+}
+function getInflight() {
+  const ctx = getSSRContext();
+  if (ctx)
+    return ctx.inflight;
+  return inflight;
+}
+function query(source, options = {}) {
+  if (isQueryDescriptor(source)) {
+    const entityMeta2 = source._entity;
+    return query(async () => {
+      const result = await source._fetch();
+      if (!result.ok)
+        throw result.error;
+      return result.data;
+    }, { ...options, key: source._key, _entityMeta: entityMeta2 });
+  }
+  const thunk = source;
+  const {
+    initialData,
+    debounce: debounceMs,
+    enabled = true,
+    key: customKey,
+    cache = getDefaultCache(),
+    _entityMeta: entityMeta
+  } = options;
+  const baseKey = deriveKey(thunk);
+  const depHashSignal = signal("");
+  const cacheKeyComputed = computed(() => {
+    const dh = depHashSignal.value;
+    return customKey ?? (dh ? `${baseKey}:${dh}` : `${baseKey}:init`);
+  });
+  function getCacheKey() {
+    return cacheKeyComputed.value;
+  }
+  function callThunkWithCapture() {
+    const captured = [];
+    const prevCb = setReadValueCallback((v) => captured.push(v));
+    let promise;
+    try {
+      promise = thunk();
+    } finally {
+      setReadValueCallback(prevCb);
+    }
+    const serialized = captured.map((v) => JSON.stringify(v)).join("|");
+    untrack(() => {
+      depHashSignal.value = hashString(serialized);
+    });
+    return promise;
+  }
+  const rawData = signal(initialData);
+  const loading = signal(initialData === undefined && enabled);
+  const revalidating = signal(false);
+  const error = signal(undefined);
+  const entityBacked = signal(false);
+  function normalizeToEntityStore(result) {
+    if (!entityMeta)
+      return;
+    const store = getEntityStore();
+    if (entityMeta.kind === "get" && result && typeof result === "object" && "id" in result) {
+      store.merge(entityMeta.entityType, result);
+      entityBacked.value = true;
+    }
+    if (entityMeta.kind === "list" && result && typeof result === "object") {
+      const listResult = result;
+      if (Array.isArray(listResult.items)) {
+        store.merge(entityMeta.entityType, listResult.items);
+        const ids = listResult.items.map((item) => item.id);
+        const queryKey = customKey ?? entityMeta.entityType;
+        store.queryIndices.set(queryKey, ids);
+        const { items: _, ...rest } = result;
+        if (Object.keys(rest).length > 0) {
+          getQueryEnvelopeStore().set(queryKey, rest);
+        }
+        entityBacked.value = true;
+      }
+    }
+  }
+  const referencedKeys = new Set;
+  const data = entityMeta ? computed(() => {
+    if (!entityBacked.value)
+      return rawData.value;
+    const raw = rawData.value;
+    const store = getEntityStore();
+    const newKeys = new Set;
+    if (entityMeta.kind === "get" && entityMeta.id) {
+      const entity = store.get(entityMeta.entityType, entityMeta.id).value;
+      if (!entity) {
+        updateRefCounts(store, referencedKeys, newKeys);
+        return;
+      }
+      const resolved = resolveReferences(entity, entityMeta.entityType, store, undefined, newKeys);
+      updateRefCounts(store, referencedKeys, newKeys);
+      return resolved;
+    }
+    const queryKey = customKey ?? entityMeta.entityType;
+    const ids = store.queryIndices.get(queryKey);
+    if (ids) {
+      const items = ids.map((id) => {
+        const entity = store.get(entityMeta.entityType, id).value;
+        if (!entity)
+          return null;
+        return resolveReferences(entity, entityMeta.entityType, store, undefined, newKeys);
+      }).filter((item) => item != null);
+      const envelope = getQueryEnvelopeStore().get(queryKey);
+      updateRefCounts(store, referencedKeys, newKeys);
+      return { ...envelope, items };
+    }
+    updateRefCounts(store, referencedKeys, newKeys);
+    return raw;
+  }) : rawData;
+  if (initialData !== undefined) {
+    cache.set(getCacheKey(), initialData);
+  }
+  const ssrTimeout = options.ssrTimeout ?? getGlobalSSRTimeout() ?? 300;
+  if (isSSR() && enabled && ssrTimeout !== 0 && initialData === undefined) {
+    const promise = callThunkWithCapture();
+    const key = untrack(() => getCacheKey());
+    const cached = cache.get(key);
+    if (cached !== undefined) {
+      promise.catch(() => {});
+      normalizeToEntityStore(cached);
+      rawData.value = cached;
+      loading.value = false;
+    } else {
+      promise.catch(() => {});
+      const ctx = getSSRContext();
+      if (ctx) {
+        ctx.queries.push({
+          promise,
+          timeout: ssrTimeout,
+          resolve: (result) => {
+            normalizeToEntityStore(result);
+            rawData.value = result;
+            loading.value = false;
+            cache.set(key, result);
+          },
+          key
+        });
+      }
+    }
+  }
+  let ssrHydrationCleanup = null;
+  let ssrHydrated = false;
+  let navPrefetchDeferred = false;
+  if (!isSSR() && enabled && initialData === undefined) {
+    const hydrationKey = customKey ?? baseKey;
+    const isNavigation = isNavPrefetchActive();
+    ssrHydrationCleanup = hydrateQueryFromSSR(hydrationKey, (result) => {
+      normalizeToEntityStore(result);
+      rawData.value = result;
+      loading.value = false;
+      cache.set(hydrationKey, result);
+      ssrHydrated = true;
+    }, { persistent: isNavigation });
+    if (!ssrHydrated && ssrHydrationCleanup !== null && isNavPrefetchActive()) {
+      if (customKey) {
+        const cached = cache.get(customKey);
+        if (cached !== undefined) {
+          normalizeToEntityStore(cached);
+          rawData.value = cached;
+          loading.value = false;
+          ssrHydrated = true;
+        }
+      }
+    }
+    if (!ssrHydrated && ssrHydrationCleanup !== null && isNavPrefetchActive()) {
+      navPrefetchDeferred = true;
+      const doneHandler = () => {
+        document.removeEventListener("vertz:nav-prefetch-done", doneHandler);
+        if (rawData.peek() === undefined && !ssrHydrated) {
+          refetchTrigger.value = refetchTrigger.peek() + 1;
+        }
+      };
+      document.addEventListener("vertz:nav-prefetch-done", doneHandler);
+      const prevCleanup = ssrHydrationCleanup;
+      ssrHydrationCleanup = () => {
+        prevCleanup?.();
+        document.removeEventListener("vertz:nav-prefetch-done", doneHandler);
+      };
+    }
+  }
+  let fetchId = 0;
+  let debounceTimer;
+  let intervalTimer;
+  const refetchIntervalOption = options.refetchInterval;
+  const hasInterval = typeof refetchIntervalOption === "function" || typeof refetchIntervalOption === "number" && refetchIntervalOption > 0;
+  let intervalIteration = 0;
+  const inflightKeys = new Set;
+  const refetchTrigger = signal(0);
+  let intervalPaused = false;
+  function scheduleInterval() {
+    if (!hasInterval || isSSR() || intervalPaused)
+      return;
+    let ms;
+    if (typeof refetchIntervalOption === "function") {
+      ms = refetchIntervalOption(rawData.peek(), intervalIteration);
+    } else {
+      ms = refetchIntervalOption;
+    }
+    if (ms === false || ms <= 0) {
+      intervalIteration = 0;
+      return;
+    }
+    intervalIteration++;
+    clearTimeout(intervalTimer);
+    intervalTimer = setTimeout(() => {
+      refetch();
+    }, ms);
+  }
+  let visibilityHandler;
+  if (hasInterval && enabled && !isSSR() && typeof document !== "undefined") {
+    visibilityHandler = () => {
+      if (document.visibilityState === "hidden") {
+        intervalPaused = true;
+        clearTimeout(intervalTimer);
+      } else {
+        intervalPaused = false;
+        refetch();
+      }
+    };
+    document.addEventListener("visibilitychange", visibilityHandler);
+  }
+  function handleFetchPromise(promise, id, key) {
+    promise.then((result) => {
+      getInflight().delete(key);
+      inflightKeys.delete(key);
+      if (id !== fetchId)
+        return;
+      cache.set(key, result);
+      normalizeToEntityStore(result);
+      rawData.value = result;
+      loading.value = false;
+      revalidating.value = false;
+      scheduleInterval();
+    }, (err) => {
+      getInflight().delete(key);
+      inflightKeys.delete(key);
+      if (id !== fetchId)
+        return;
+      error.value = err;
+      loading.value = false;
+      revalidating.value = false;
+      scheduleInterval();
+    });
+  }
+  function startFetch(fetchPromise, key) {
+    const id = ++fetchId;
+    untrack(() => {
+      if (rawData.value !== undefined) {
+        revalidating.value = true;
+      } else {
+        loading.value = true;
+      }
+      error.value = undefined;
+    });
+    const existing = getInflight().get(key);
+    if (existing) {
+      handleFetchPromise(existing, id, key);
+      return;
+    }
+    getInflight().set(key, fetchPromise);
+    inflightKeys.add(key);
+    handleFetchPromise(fetchPromise, id, key);
+  }
+  function refetch() {
+    const key = getCacheKey();
+    cache.delete(key);
+    getInflight().delete(key);
+    refetchTrigger.value = refetchTrigger.peek() + 1;
+  }
+  let disposeFn;
+  if (enabled) {
+    let isFirst = true;
+    disposeFn = lifecycleEffect(() => {
+      refetchTrigger.value;
+      if (isFirst && ssrHydrated) {
+        isFirst = false;
+        return;
+      }
+      if (isFirst && navPrefetchDeferred) {
+        if (customKey) {
+          const cached = untrack(() => cache.get(customKey));
+          if (cached !== undefined) {
+            untrack(() => {
+              rawData.value = cached;
+              loading.value = false;
+            });
+            isFirst = false;
+            return;
+          }
+        } else {
+          const trackPromise = callThunkWithCapture();
+          trackPromise.catch(() => {});
+          const derivedKey = untrack(() => getCacheKey());
+          const cached = untrack(() => cache.get(derivedKey));
+          if (cached !== undefined) {
+            untrack(() => {
+              rawData.value = cached;
+              loading.value = false;
+            });
+            isFirst = false;
+            return;
+          }
+        }
+        isFirst = false;
+        return;
+      }
+      if (customKey) {
+        const existing = untrack(() => getInflight().get(customKey));
+        if (existing) {
+          const id = ++fetchId;
+          untrack(() => {
+            if (rawData.value !== undefined) {
+              revalidating.value = true;
+            } else {
+              loading.value = true;
+            }
+            error.value = undefined;
+          });
+          handleFetchPromise(existing, id, customKey);
+          isFirst = false;
+          return;
+        }
+      }
+      const promise = callThunkWithCapture();
+      const key = untrack(() => getCacheKey());
+      if (!customKey) {
+        const existing = untrack(() => getInflight().get(key));
+        if (existing) {
+          promise.catch(() => {});
+          const id = ++fetchId;
+          untrack(() => {
+            if (rawData.value !== undefined) {
+              revalidating.value = true;
+            } else {
+              loading.value = true;
+            }
+            error.value = undefined;
+          });
+          handleFetchPromise(existing, id, key);
+          isFirst = false;
+          return;
+        }
+      }
+      const isNavigation = ssrHydrationCleanup !== null;
+      const shouldCheckCache = isNavigation || (isFirst ? !!customKey : !customKey);
+      if (shouldCheckCache) {
+        const cached = untrack(() => cache.get(key));
+        if (cached !== undefined) {
+          promise.catch(() => {});
+          untrack(() => {
+            rawData.value = cached;
+            loading.value = false;
+            error.value = undefined;
+          });
+          isFirst = false;
+          scheduleInterval();
+          return;
+        }
+      }
+      if (isFirst && initialData !== undefined) {
+        promise.catch(() => {});
+        isFirst = false;
+        scheduleInterval();
+        return;
+      }
+      isFirst = false;
+      if (debounceMs !== undefined && debounceMs > 0) {
+        clearTimeout(debounceTimer);
+        promise.catch(() => {});
+        debounceTimer = setTimeout(() => {
+          startFetch(promise, key);
+        }, debounceMs);
+      } else {
+        startFetch(promise, key);
+      }
+    });
+  }
+  function dispose() {
+    if (referencedKeys.size > 0) {
+      const store = getEntityStore();
+      for (const key of referencedKeys) {
+        const [type, id] = splitRefKey(key);
+        store.removeRef(type, id);
+      }
+      referencedKeys.clear();
+    }
+    disposeFn?.();
+    unsubscribeBus?.();
+    unregisterFromRegistry?.();
+    ssrHydrationCleanup?.();
+    clearTimeout(debounceTimer);
+    clearTimeout(intervalTimer);
+    if (visibilityHandler && typeof document !== "undefined") {
+      document.removeEventListener("visibilitychange", visibilityHandler);
+    }
+    fetchId++;
+    for (const key of inflightKeys) {
+      getInflight().delete(key);
+    }
+    inflightKeys.clear();
+  }
+  let unsubscribeBus;
+  let unregisterFromRegistry;
+  if (entityMeta && enabled && !isSSR()) {
+    unsubscribeBus = getMutationEventBus().subscribe(entityMeta.entityType, refetch);
+    unregisterFromRegistry = registerActiveQuery(entityMeta, refetch);
+  }
+  _tryOnCleanup(dispose);
+  return {
+    data,
+    loading,
+    revalidating,
+    error,
+    refetch,
+    revalidate: refetch,
+    dispose
+  };
+}
+function updateRefCounts(store, oldKeys, newKeys) {
+  for (const key of oldKeys) {
+    if (!newKeys.has(key)) {
+      const [type, id] = splitRefKey(key);
+      store.removeRef(type, id);
+    }
+  }
+  for (const key of newKeys) {
+    if (!oldKeys.has(key)) {
+      const [type, id] = splitRefKey(key);
+      store.addRef(type, id);
+    }
+  }
+  oldKeys.clear();
+  for (const key of newKeys)
+    oldKeys.add(key);
+}
+function splitRefKey(key) {
+  const idx = key.indexOf(":");
+  return [key.slice(0, idx), key.slice(idx + 1)];
+}
+
+// src/query/query-match.ts
+var cache = new WeakMap;
+function queryMatch(queryResult, handlers) {
+  const key = queryResult;
+  const existing = cache.get(key);
+  if (existing && !existing.disposed) {
+    existing.handlers = handlers;
+    return existing.wrapper;
+  }
+  if (existing) {
+    cache.delete(key);
+  }
+  const wrapper = getAdapter().createElement("span");
+  wrapper.style.display = "contents";
+  const entry = { wrapper, handlers, disposed: false };
+  cache.set(key, entry);
+  let currentBranch = null;
+  let branchCleanups = [];
+  const outerScope = pushScope();
+  domEffect(() => {
+    const isLoading = queryResult.loading.value;
+    const err = queryResult.error.value;
+    const dataValue = queryResult.data.value;
+    let branch;
+    if (isLoading || err === undefined && dataValue === undefined) {
+      branch = "loading";
+    } else if (err !== undefined) {
+      branch = "error";
+    } else {
+      branch = "data";
+    }
+    if (branch === currentBranch) {
+      return;
+    }
+    runCleanups(branchCleanups);
+    while (wrapper.firstChild) {
+      wrapper.removeChild(wrapper.firstChild);
+    }
+    currentBranch = branch;
+    const scope = pushScope();
+    let branchResult = null;
+    if (branch === "loading") {
+      branchResult = entry.handlers.loading();
+    } else if (branch === "error") {
+      branchResult = entry.handlers.error(err);
+    } else {
+      const dataSignal = queryResult.data;
+      const dataProxy = new Proxy({}, {
+        get(_target, prop, receiver) {
+          const current = dataSignal.value;
+          if (current == null)
+            return;
+          const value = Reflect.get(current, prop, receiver);
+          if (typeof value === "function") {
+            return value.bind(current);
+          }
+          return value;
+        },
+        has(_target, prop) {
+          const current = dataSignal.value;
+          if (current == null)
+            return false;
+          return Reflect.has(current, prop);
+        },
+        ownKeys() {
+          const current = dataSignal.value;
+          if (current == null)
+            return [];
+          return Reflect.ownKeys(current);
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+          const current = dataSignal.value;
+          if (current == null)
+            return;
+          return Reflect.getOwnPropertyDescriptor(current, prop);
+        }
+      });
+      branchResult = entry.handlers.data(dataProxy);
+    }
+    popScope();
+    branchCleanups = scope;
+    if (branchResult != null && isRenderNode(branchResult)) {
+      wrapper.appendChild(branchResult);
+    }
+  });
+  popScope();
+  const dispose = () => {
+    entry.disposed = true;
+    runCleanups(branchCleanups);
+    runCleanups(outerScope);
+    cache.delete(key);
+  };
+  wrapper.dispose = dispose;
+  _tryOnCleanup(dispose);
+  return wrapper;
+}
+
+export { MemoryCache, invalidate, deriveKey, registerRelationSchema, getRelationSchema, resetRelationSchemas_TEST_ONLY, EntityStore, QueryEnvelopeStore, getEntityStore, getQueryEnvelopeStore, getMutationEventBus, query, queryMatch };