@uniweb/core 0.14.0 → 0.15.0

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@uniweb/core",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "Core classes for the Uniweb platform - Uniweb, Website, Page, Block",
   "type": "module",
   "exports": {
     ".": "./src/index.js",
     "./base-path": "./src/base-path.js",
-    "./collection-address": "./src/collection-address.js",
+    "./collection-address": "./src/query-address.js",
+    "./query-address": "./src/query-address.js",
     "./data-paths": "./src/data-paths.js",
     "./detail-url": "./src/detail-url.js",
     "./fetch-config": "./src/fetch-config.js",
@@ -41,7 +42,7 @@
     "vitest": "^4.1.7"
   },
   "dependencies": {
-    "@uniweb/semantic-parser": "^1.3.1",
+    "@uniweb/semantic-parser": "^1.4.0",
     "@uniweb/theming": "^0.1.15"
   },
   "scripts": {

package/src/datastore.js

@@ -62,7 +62,7 @@ export default class DataStore {
    *
    * Two forms:
    *   - `subscribe(fn)`      — fires after every successful `set()` (all keys).
-   *   - `subscribe(key, fn)` — fires only when `set(key, ...)` is called.
+   *   - `subscribe(key, fn)` — fires only when `set(key, ...)` or `delete(key)` is called.
    *
    * The global form is useful for debugging / blanket observers. The keyed
    * form is what Layer-3 kit hooks (`useFetched`, `useCacheEntry`) use so
@@ -131,6 +131,29 @@ export default class DataStore {
     }
   }
 
+  /**
+   * Drop one entry, and any in-flight record for the same key.
+   *
+   * Fires the key's subscribers (and the global ones) so an observer re-reads
+   * and sees the absence, exactly as it would see a write. Exists for the case
+   * `clear()` is too blunt for: one consumer's entries must leave memory — a
+   * viewer's records at sign-out — while everything else stays warm.
+   *
+   * @param {string} key
+   * @returns {boolean} true if an entry was removed
+   */
+  delete(key) {
+    const had = this._cache.delete(key)
+    this._inflight.delete(key)
+    if (!had) return false
+    for (const fn of this._listeners) fn()
+    const keyed = this._keyedListeners.get(key)
+    if (keyed) {
+      for (const fn of keyed) fn()
+    }
+    return true
+  }
+
   /**
    * In-flight fetch registry — used by the dispatcher to dedup concurrent
    * requests and collect abort signals so the underlying fetch is cancelled

package/src/index.js

@@ -20,15 +20,21 @@ export { default as ObservableState } from './observable-state.js'
 
 // Utilities
 export { substitutePlaceholders } from './substitute-placeholders.js'
-export {
-  resolveQueryAddress,
-  resolveRecordAddressPattern,
-} from './query-address.js'
+// ⛔ `resolveQueryAddress` / `resolveRecordAddressPattern` are NOT re-exported
+// here. They are read by `./fetch-config.js` and by nothing else in any repo
+// (measured 2026-09-01 over every .js/.jsx/.mjs/.ts/.tsx file in the
+// workspace). A consumer that needs them imports `@uniweb/core/query-address`,
+// which is a declared subpath and a zero-dependency leaf — the same reach
+// `route-match` and `section-id` already have. Re-exporting an internal from
+// the package entry is not free: the import-map bridge enumerates this file's
+// surface and emits a live named re-export for every one, so nothing here can
+// ever be tree-shaken on the hosted lane.
 export { resolveFetchConfigs } from './fetch-config.js'
 export { buildDetailConfig } from './detail-url.js'
+// `isWildcardLanguages` is likewise internal — `./locale-config.js` reads it
+// and nothing else does. Same subpath escape hatch: `@uniweb/core/locale-config`.
 export {
   normalizeLanguageList,
-  isWildcardLanguages,
   resolveDefaultLocale,
   resolvePublishableLocales,
   validateLanguageConfig
@@ -42,8 +48,18 @@ export {
   isDataUrl
 } from './data-paths.js'
 export { evaluate as evaluateWhere, match as matchWhere } from './where.js'
-export { isRichSchema, normalizeSchema } from './schemas.js'
-export { default as Tracker } from './tracker.js'
+export { isRichSchema } from './schemas.js'
+// ⛔ `normalizeSchema` MOVED to `@uniweb/schemas/editor-form` (2026-09-01) —
+// it is editor-only and never called `isRichSchema`. Still exported here for
+// ONE more release so `frontend` (a `workspace:*` pin, so a removal is live
+// at commit time) can migrate its single import. Delete both lines then.
+export { normalizeSchema } from './schemas.js'
+// ⛔ `Tracker` is NOT on the package entry. It is a FEATURE, not part of the
+// object graph this package exists to define, and putting it here made every
+// consumer of core carry 1,576 gzip of it -- press, unipress, `@uniweb/api`
+// and every SSR isolate included -- for a class only the browser runtime ever
+// wires. Its one importer already reaches it correctly, through the
+// `@uniweb/core/tracker` subpath (`runtime/src/wire-foundation.js`).
 // Also available as the zero-dependency leaves `@uniweb/core/services` and
 // `@uniweb/core/base-path` — which is how `@uniweb/runtime` reaches them,
 // since it must not pull the package root into an SSR/Worker bundle.

package/src/schemas.js

@@ -37,6 +37,18 @@ export function isRichSchema(schema) {
 }
 
 /**
+ * ⛔ **DEPRECATED — MOVED to `@uniweb/schemas/editor-form` (2026-09-01).**
+ * This copy stays only so `frontend`, which pins core as `workspace:*` and
+ * would break at commit time, can migrate its one import. Delete it once that
+ * lands; nothing else in any repo reads it.
+ *
+ * ⭐ **It never belonged here.** It does not call `isRichSchema` and never did
+ * — it re-inlines the same three checks — so nothing but adjacency held it in
+ * this file. The two answer different questions for different audiences:
+ * `isRichSchema` is a render-time dispatch predicate (`prepare-props.js`,
+ * `runtime-schema.js`) and stays; this is read only by an editor, while core
+ * ships to every site in every lane and is not tree-shaken on the hosted one.
+ *
  * Normalize any authored `data:` schema shape to the rich form the editor
  * renders, or null when it is not a single form at all.
  *
@@ -48,8 +60,11 @@ export function isRichSchema(schema) {
  *   { fields: { name: spec } }     a RESOLVED NAMED REF          → FALSE
  *   { name: spec }                 meta.js inline field map      → false
  *
- * The middle row is the important one and the reason this helper is in `core`
- * rather than in the editor. A named ref (`'@/article'`, `'@std/person'`) is the
+ * The middle row is the important one and the reason this helper exists at all
+ * (it once read "the reason it is in `core` rather than in the editor" — that
+ * was the wrong conclusion from a right observation: the gap is real, closing
+ * it in one shared place is right, and `@uniweb/schemas` is that place).
+ * A named ref (`'@/article'`, `'@std/person'`) is the
  * FIRST authoring form the docs show, and `validateAndNormalizeSchema` in the
  * build resolves it to `{ fields: <MAP> }` — a map, not an array. So filtering
  * with `isRichSchema` discards not merely "simple" schemas but the primary

package/src/uniweb.js

@@ -12,7 +12,6 @@
  */
 
 import Website from './website.js'
-import Tracker from './tracker.js'
 
 export default class Uniweb {
   /**
@@ -72,21 +71,40 @@ export default class Uniweb {
     // Populated by prerender before rendering, read synchronously by Icon.
     this.iconCache = new Map()
 
-    // Site tracking — one event stream.
+    // Site tracking — one event stream. The runtime installs it in L2
+    // (`wire-foundation.js` → `wireTracker`), and only for a site that declares
+    // a destination. It cannot be configured here even though `activeWebsite`
+    // already exists two lines up, because the address is resolved against
+    // `website.basePath` and **that is still `''` at this point** —
+    // `setBasePath()` runs later, from the runtime. Resolving here would
+    // silently drop the base prefix on every subdirectory deployment.
     //
-    // ⛔ Deliberately constructed DISABLED, and the runtime replaces it in L2
-    // (`wire-foundation.js` → `wireTracker`). It cannot be configured here even
-    // though `activeWebsite` already exists two lines up, because the address is
-    // resolved against `website.basePath` and **that is still `''` at this
-    // point** — `setBasePath()` runs later, from the runtime. Resolving here
-    // would silently drop the base prefix on every subdirectory deployment.
+    // ⛔ **Core does not construct a Tracker, and must not start.** Until
+    // 2026-09-01 this line was `new Tracker()` — a working no-op, justified as
+    // letting `uniweb.tracking.track(…)` run unguarded in every lane. Two
+    // things were wrong with that. It put a *feature* in the object graph,
+    // which is not what this class is for; and the guard it bought was never
+    // taken up — every reader in the workspace already optional-chains
+    // (`block.js`'s `track()`, and the runtime's `usePageView`,
+    // `useSectionViews`, `useOutboundClicks`, `useSectionClicks`), so the
+    // invariant lived only in the comment. Cost of carrying it: 1,576 gzip in
+    // core's chunk, which press, unipress, `@uniweb/api` and every SSR isolate
+    // paid for a class they never wire.
     //
-    // The disabled instance is not a placeholder to null-check: it is a working
-    // no-op, so `uniweb.tracking.track(…)` is safe in every lane — press,
-    // unipress, an SSR isolate, or before wiring — with no guard at the call
-    // site. Same slot-declared-here-so-seal-permits-assignment pattern as
+    // ⇒ **Read it as nullable.** `globalThis.uniweb?.tracking?.track(…)` is
+    // the call shape, and it is what every existing caller already writes.
+    // Same slot-declared-here-so-seal-permits-assignment pattern as
     // `defaultInsets` above.
-    this.tracking = new Tracker()
+    this.tracking = null
+
+    // Reserved for `@uniweb/api` — the one client instance per page. That
+    // package is bundled into each foundation, so a page with a primary
+    // foundation and extensions holds several copies of its code; the first to
+    // need a client creates one and parks it here, and every other copy adopts
+    // it instead of creating another. Core implements nothing on it: declared
+    // null so the seal permits the assignment, nothing more. Same pattern as
+    // `defaultInsets` above.
+    this.api = null
 
     Object.seal(this)
   }