@uniweb/core 0.14.1 → 0.16.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/core",
-  "version": "0.14.1",
+  "version": "0.16.0",
   "description": "Core classes for the Uniweb platform - Uniweb, Website, Page, Block",
   "type": "module",
   "exports": {
@@ -43,7 +43,7 @@
   },
   "dependencies": {
     "@uniweb/theming": "^0.1.15",
-    "@uniweb/semantic-parser": "^1.3.1"
+    "@uniweb/semantic-parser": "^1.4.0"
   },
   "scripts": {
     "test": "vitest run"

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,13 @@ 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'
+// ⛔ `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

@@ -1,18 +1,26 @@
 /**
- * Shared helpers for rich form schemas.
- *
- * Rich schemas live under `data.schemas` in a component's meta.js. They
- * drive two author input paths that both land at `content.data[schema-id]`:
- *
- *   1. Tagged markdown blocks (``` ```yaml:<id> ``` ```)
- *   2. The FormBlock editor widget
- *
- * Detection is shared across the build pipeline (emit path), the runtime
- * (dispatch in applySchemas), and the editor (filter for FormBlock menu)
- * so all three agree on what counts as a rich schema.
- *
- * Conditional field visibility (a rich-schema feature) is an editor-only
- * concern and is not implemented here — the editor owns its own evaluator.
+ * The rich-form-schema predicate. One function, and deliberately only one.
+ *
+ * Rich schemas live under `data.schemas` in a component's meta.js. They drive
+ * two author input paths that both land at `content.data[schema-id]`: tagged
+ * markdown blocks (``` ```yaml:<id> ``` ```) and the editor's FormBlock widget.
+ *
+ * `isRichSchema` is a **dispatch** predicate — "is this already the rich shape?"
+ * — and it is read at render by `runtime/src/prepare-props.js` (`applySchemas`)
+ * and at build by `build/src/runtime-schema.js`. Both are on the hot path of
+ * every site, which is what earns it a place in this package.
+ *
+ * ⛔ **Do not add editor-side schema code here.** `normalizeSchema` — "can this
+ * be edited, and as what?" — sat beside this function until 2026-09-01 purely
+ * because the two were adjacent; it never called `isRichSchema` and had no
+ * consumer outside the editor. `@uniweb/core` loads on every site in every lane
+ * and is not tree-shaken on the hosted one, so an editor-only function on its
+ * entry is paid for by every visitor of every site. It now lives in the
+ * zero-dependency leaf that owns what a data-schema *means*:
+ * **`@uniweb/schemas/editor-form`**.
+ *
+ * Conditional field visibility (a rich-schema feature) is likewise editor-only
+ * and is not implemented here — the editor owns its own evaluator.
  */
 
 /**
@@ -35,76 +43,3 @@ export function isRichSchema(schema) {
   if (schema.childSchema && typeof schema.childSchema === 'object') return true
   return false
 }
-
-/**
- * Normalize any authored `data:` schema shape to the rich form the editor
- * renders, or null when it is not a single form at all.
- *
- * WHY THIS EXISTS. `isRichSchema` answers "is this already the rich shape?",
- * which is the right question for dispatch and the wrong one for "can this be
- * edited". There are THREE authored shapes and it accepts exactly one:
- *
- *   { fields: [ {id, …} ] }        meta.js inline rich-form      → true
- *   { 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
- * 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
- * documented one, and any consumer that wants to render it has to re-derive the
- * conversion. Three consumers re-deriving it is exactly the divergence the
- * shared predicate was introduced to prevent.
- *
- * A field map is an unordered `fields[]`, so the conversion is mechanical.
- * Ordering comes from `Object.entries`, which is insertion order for string keys
- * — i.e. the order the author wrote, which is the order a form should show.
- *
- * `sections` returns null on purpose: a sectioned data-schema describes a Model
- * with several sections, which is not one form. Flattening it would invent a
- * layout the author never expressed.
- *
- * @param {*} schema - any authored or resolved `data:` schema value
- * @returns {{ fields: Array<object> } | null} the rich shape, or null
- */
-export function normalizeSchema(schema) {
-  if (!schema || typeof schema !== 'object' || Array.isArray(schema))
-    return null
-
-  // Already rich — hand back untouched. Composite/childSchema variants are rich
-  // by `isRichSchema`'s definition and are not ours to reshape.
-  if (Array.isArray(schema.fields)) return schema
-  if (schema.isComposite === true || schema.childSchema) return schema
-
-  // A sectioned Model is not a single form.
-  if (schema.sections !== undefined) return null
-
-  const mapToFields = (map) =>
-    Object.entries(map).map(([id, spec]) =>
-      typeof spec === 'string' ? { id, type: spec } : { id, ...spec }
-    )
-
-  // A resolved named ref: `fields` present, as a map.
-  if (schema.fields && typeof schema.fields === 'object') {
-    const { fields, ...rest } = schema
-    return { ...rest, fields: mapToFields(fields) }
-  }
-
-  // An inline field map: no `fields` key, so every value must be an OBJECT
-  // carrying `type`.
-  //
-  // The bare-type string shorthand (`{ cpu: 'string' }`) is deliberately NOT
-  // accepted here, even though schema FILES support it. Without a `fields` key
-  // there is nothing to distinguish it from ordinary data: `{ name: 'Acme' }` and
-  // `{ cpu: 'string' }` are the same shape, and an earlier cut of this function
-  // turned `{ name, description }` into a two-field form. Erring toward null
-  // costs an author the object spelling; erring the other way invents a form out
-  // of a config block.
-  const entries = Object.entries(schema)
-  if (!entries.length) return null
-  const isFieldSpec = ([, v]) =>
-    v && typeof v === 'object' && !Array.isArray(v) && v.type !== undefined
-  if (!entries.every(isFieldSpec)) return null
-  return { fields: mapToFields(schema) }
-}

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,31 @@ 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