@unitninety/site-kit 1.6.4 → 1.6.6

package/src/server/render.tsx

@@ -4,13 +4,16 @@ import type { RouteRead } from '../site'
 import type { LanguageLinks } from '../languages/routing'
 import { LanguageProvider } from '../switcher/LanguageSwitcher'
 import { DraftBlocks } from '../bridge/DraftBlocks'
+import { blockAnchor } from '../elements/blockAnchor'
+import { ID_RE } from '../elements/ids'
+import { BlockAnchors } from './BlockAnchors'
 
 type BlockItem = { _id: string; _block: string; _hidden?: boolean; $path?: string } & Record<string, unknown>
 /** What a block declared with `entry:` receives, when the document being rendered is an entry page. */
 type EntryProp = { id: string; slug?: string; route?: string; fields?: Record<string, unknown> }
 
 export function createRender(site: Site) {
-  const Blocks = ({ value, slot, entry }: { value: unknown; slot?: ReactNode; entry?: EntryProp }): ReactElement => {
+  const Blocks = ({ value, slot, entry, anchors = true }: { value: unknown; slot?: ReactNode; entry?: EntryProp; anchors?: boolean }): ReactElement => {
     const items = ((Array.isArray(value) ? value : []) as BlockItem[]).filter(item => item._hidden !== true)
     const renderedItems = items.map((item) => {
       if (item._block === 'SLOT') return createElement(Fragment, { key: item._id }, slot)
@@ -19,18 +22,20 @@ export function createRender(site: Site) {
       const { _id, _block, _hidden, $path, ...fields } = item
       // zones arrive rendered: replace each zone-typed field with <Blocks/>, threading `entry` through
       const props: Record<string, unknown> = { ...fields }
-      for (const [name, decl] of Object.entries(def.fields)) if ('container' in (decl as object) && (decl as { container: string }).container === 'u90/zone') props[name] = createElement(Blocks, { value: fields[name], entry })
+      for (const [name, decl] of Object.entries(def.fields)) if ('container' in (decl as object) && (decl as { container: string }).container === 'u90/zone') props[name] = createElement(Blocks, { value: fields[name], entry, anchors })
       // a block declared with `entry:` renders inside that collection's entry pages and receives the entry itself
       if (def.entry) props.entry = entry
       const rendered = createElement(def.component as never, { key: _id, ...props } as never)
-      return $path ? createElement('div', { key: _id, 'data-u90-block': $path, style: { display: 'contents' } }, rendered) : rendered
+      if (!anchors && !$path) return rendered
+      const anchor = anchors && ID_RE.test(_id) ? blockAnchor(_id) : undefined
+      return createElement('div', { key: _id, id: anchor, 'data-u90-anchor': anchor ? '' : undefined, 'data-u90-block': $path, style: { display: 'contents' } }, rendered)
     })
     return items.some((item) => item.$path)
       ? createElement(DraftBlocks, { items: items.map((item, index) => ({ id: item._id, path: item.$path, content: renderedItems[index] })) })
       : createElement(Fragment, null, ...renderedItems)
   }
   const Layout = ({ chain, layouts, children }: { chain: string[]; layouts: Record<string, unknown>; children: ReactNode }): ReactElement =>
-    chain.reduceRight<ReactElement>((inner, key) => createElement(Blocks, { value: (layouts[key] as { blocks: unknown })?.blocks, slot: inner }), createElement(Fragment, null, children))
+    chain.reduceRight<ReactElement>((inner, key) => createElement(Blocks, { value: (layouts[key] as { blocks: unknown })?.blocks, slot: inner, anchors: false }), createElement(Fragment, null, children))
   /** `language`, on a language site's page only, puts the page's language and its addresses within reach of `LanguageSwitcher`. Without it the tree is the one it always was. */
   const render = (read: RouteRead, language?: LanguageLinks): ReactElement => {
     const doc = read.read as { blocks?: unknown; fields?: Record<string, unknown> } | undefined
@@ -40,7 +45,8 @@ export function createRender(site: Site) {
       ? { id: document.id, slug: document.slug, route: document.collection ? site.collections[document.collection]?.route?.replace(':slug', document.slug) : undefined, fields: doc?.fields }
       : undefined
     const tree = <Layout chain={document?.layoutChain ?? []} layouts={read.layouts ?? {}}><Blocks value={doc?.blocks} entry={entry} /></Layout>
-    return language ? createElement(LanguageProvider, { value: language }, tree) : tree
+    const anchored = <BlockAnchors key={document?.id}>{tree}</BlockAnchors>
+    return language ? createElement(LanguageProvider, { value: language }, anchored) : anchored
   }
   return { Blocks, Layout, render }
 }

package/src/site/defineSite.ts

@@ -1,3 +1,4 @@
+import { FormsSchema, type FormDeclaration } from './forms'
 import { seedIssues, validateSchema, type BlockDecl, type CollectionDecl, type FieldDecl, type Issue, type Schema, type SeedKnown, type ZoneDecl } from '../elements'
 import { SLOT } from './documents'
 import type { BlockDef, CollectionDef, LayoutDef, PageDef, PageTypeDef, Seo, Singles, Site, SiteManifest } from './types'
@@ -35,7 +36,8 @@ const misplacedZones = (decl: FieldDecl, at: string, direct: boolean, into: Issu
 const PAGE_KEY = /^[a-z][a-zA-Z0-9_-]*$/
 const strip = (fields: Record<string, unknown>) => Object.fromEntries(Object.entries(fields).map(([k, v]) => [k, JSON.parse(JSON.stringify(v))])) as Record<string, FieldDecl>
 
-export function defineSite(input: { singles: Singles; collections: Record<string, CollectionDef>; layouts: Record<string, LayoutDef>; pages: Record<string, PageDef>; pageTypes: Record<string, PageTypeDef>; seo?: Seo; knowledge?: KnowledgePolicyV1 }): Site {
+export function defineSite(input: { singles: Singles; collections: Record<string, CollectionDef>; layouts: Record<string, LayoutDef>; pages: Record<string, PageDef>; pageTypes: Record<string, PageTypeDef>; seo?: Seo; knowledge?: KnowledgePolicyV1; forms?: FormDeclaration[] }): Site {
+  const forms = input.forms === undefined ? undefined : FormsSchema.parse(input.forms)
   const defaults = Object.entries(input.layouts).filter(([, l]) => l.default)
   if (defaults.length !== 1) throw new Error(`A site needs exactly one default layout; found ${defaults.length}.`)
   const defaultLayout = defaults[0][0]
@@ -96,7 +98,7 @@ export function defineSite(input: { singles: Singles; collections: Record<string
   const schema: Schema = {
     blocks: Object.fromEntries([...blocks.values()].map((b) => [b.name, { name: b.name, label: b.label, fields: strip(b.fields), ...(b.shared ? { shared: b.shared } : {}), ...(b.entry ? { entry: b.entry.name } : {}), order: Object.keys(b.fields) } satisfies BlockDecl])),
     collections: Object.fromEntries(Object.values(input.collections).map((c) => [c.name, { name: c.name, label: c.label, fields: strip(c.fields), ...(c.authoring ? { authoring: JSON.parse(JSON.stringify(c.authoring)) } : {}), ...(c.template ? { template: JSON.parse(JSON.stringify(c.template.zone)) } : {}), ...(c.defaultSort ? { defaultSort: c.defaultSort } : {}), order: Object.keys(c.fields) } satisfies CollectionDecl])),
-    singles: Object.fromEntries(Object.values(input.singles).map((s) => [s.key, { key: s.key, field: JSON.parse(JSON.stringify(s.decl)) }])),
+    singles: Object.fromEntries(Object.values(input.singles).map((s) => [s.key, { key: s.key, ...(s.editor ? { editor: s.editor } : {}), field: JSON.parse(JSON.stringify(s.decl)) }])),
   }
   // Finding 1: seed entries were checked only when seeded, at the platform or in the defaults store.
   const known: SeedKnown = {
@@ -106,6 +108,7 @@ export function defineSite(input: { singles: Singles; collections: Record<string
   const badSeeds = Object.values(input.collections).flatMap((c) => (c.entries ?? []).flatMap((e) => seedIssues(schema, { kind: 'entry', collection: c.name }, { fields: e.fields, blocks: e.blocks }, `collections.${c.name}.entries.${e.slug}`, known)))
   if (badSeeds.length) throw new SiteDeclarationError(badSeeds)
   return {
+    ...(forms !== undefined ? { forms } : {}),
     ...(input.knowledge !== undefined ? { knowledge: input.knowledge } : {}),
     singles: input.singles, collections: input.collections, blocks: Object.fromEntries(blocks), schema, seo: input.seo ?? {}, defaultLayout,
     layouts: Object.fromEntries(Object.entries(input.layouts).map(([k, l]) => [k, { default: !!l.default, parent: l.parent, blocks: l.entries.map((e) => (e === SLOT ? 'SLOT' : e.name)) }])),
@@ -128,5 +131,5 @@ export function manifestFrom(site: Site): SiteManifest {
     pageTypes: Object.keys(site.pageTypes),
     layouts: Object.keys(site.layouts),
   }
-  return { ...(site.knowledge !== undefined ? { knowledge: site.knowledge } : {}), schema: r.schema, layouts: site.layouts, pages: site.pages, pageTypes: site.pageTypes, entries, collections, routes, seo: site.seo, bridgeVersion: 4, siteKitVersion: SITE_KIT_VERSION, order }
+  return { ...(site.forms !== undefined ? { forms: FormsSchema.parse(site.forms) } : {}), ...(site.knowledge !== undefined ? { knowledge: site.knowledge } : {}), schema: r.schema, layouts: site.layouts, pages: site.pages, pageTypes: site.pageTypes, entries, collections, routes, seo: site.seo, bridgeVersion: 4, siteKitVersion: SITE_KIT_VERSION, order }
 }

package/src/site/documents.ts

@@ -4,8 +4,8 @@ import type { BlockDef, CollectionDef, Decl, EntrySeed, Fields, LayoutDef, PageD
 export const SLOT = 'SLOT' as const
 export const humanise = (name: string) => name.replace(/([a-z])([A-Z])/g, '$1 $2').replace(/^./, (c) => c.toUpperCase())
 
-export const defineSingles = <M extends Record<string, Decl<unknown>>>(map: M): { [K in keyof M]: SingleDef<M[K] extends Decl<infer R> ? R : never> } =>
-  Object.fromEntries(Object.entries(map).map(([key, decl]) => [key, { key, decl }])) as never
+export const defineSingles = <M extends Record<string, Decl<unknown>>>(map: M, authoring: Partial<Record<keyof M, { editor: 'cms' | 'canvas' }>> = {}): { [K in keyof M]: SingleDef<M[K] extends Decl<infer R> ? R : never> } =>
+  Object.fromEntries(Object.entries(map).map(([key, decl]) => [key, { key, decl, ...authoring[key] }])) as never
 export const collection = <F extends Fields>(name: string, o: { label?: string; fields: F; route?: string; defaultSort?: CollectionDef['defaultSort']; entries?: EntrySeed[]; authoring?: CollectionDef['authoring'] }): CollectionDef<F> =>
   ({ kind: 'collection', name, label: o.label ?? humanise(name), fields: o.fields, route: o.route, defaultSort: o.defaultSort, ...(o.authoring ? { authoring: o.authoring } : {}), ...(o.entries ? { entries: o.entries } : {}) })
 export const withTemplate = <C extends CollectionDef>(c: C, zone: Decl<unknown>, o: { layout?: string } = {}): C =>

package/src/site/forms.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod'
+
+const identifier = z.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/).max(100)
+const label = z.string().trim().min(1).max(200)
+export const FormFieldSchema = z.strictObject({
+ name: identifier, label,
+ type: z.enum(['checkbox', 'date', 'email', 'number', 'select', 'tel', 'text', 'textarea']),
+ required: z.boolean().optional(), role: z.enum(['email', 'name', 'phone']).optional(),
+ options: z.array(label).max(200).optional(),
+}).superRefine((field, ctx) => {
+ if (field.type === 'select' && !field.options?.length) ctx.addIssue({ code: 'custom', path: ['options'], message: 'Select fields need options.' })
+ if (field.options && new Set(field.options).size !== field.options.length) ctx.addIssue({ code: 'custom', path: ['options'], message: 'Options must be unique.' })
+})
+export const FormDeclarationSchema = z.strictObject({
+ slug: identifier, label, fields: z.array(FormFieldSchema).min(1).max(100),
+ recipients: z.array(z.email()).max(50).optional(),
+}).superRefine((form, ctx) => {
+ const names = new Set<string>()
+ form.fields.forEach((field, i) => {
+  if (names.has(field.name)) ctx.addIssue({ code: 'custom', path: ['fields', i, 'name'], message: 'Field names must be unique.' })
+  names.add(field.name)
+ })
+})
+export const FormsSchema = z.array(FormDeclarationSchema).max(100).superRefine((forms, ctx) => {
+ const slugs = new Set<string>()
+ forms.forEach((form, i) => {
+  if (slugs.has(form.slug)) ctx.addIssue({ code: 'custom', path: [i, 'slug'], message: 'Form slugs must be unique.' })
+  slugs.add(form.slug)
+ })
+})
+export type FormDeclaration = z.infer<typeof FormDeclarationSchema>
+export type FormFieldDeclaration = z.infer<typeof FormFieldSchema>

package/src/site/index.ts

@@ -15,3 +15,5 @@ export { sitemapFor } from '../seo/sitemap'
 
 export { SeoSeedsSchema, DocumentSeoSeedSchema, SiteSeoSeedSchema, seoSeedIssues, seoSeedAssets, type SeoSeeds, type DocumentSeoSeed, type SiteSeoSeed } from '../seo/seeds'
 export { CollectionViewSchema, CollectionViewsSchema, collectionViewFields, defaultCollectionView, reconcileCollectionView, validateCollectionView, collectionViewsIssues, type CollectionView, type CollectionViews, type CollectionViewField } from './formView'
+
+export { FormsSchema, FormDeclarationSchema, FormFieldSchema, type FormDeclaration, type FormFieldDeclaration } from './forms'

package/src/site/types.ts

@@ -1,4 +1,5 @@
 import type { KnowledgePolicyV1 } from '../features/contracts/knowledgePolicy'
+import type { FormDeclaration } from './forms'
 import type { ReactNode } from 'react'
 import type { BlockDecl, CollectionDecl, FieldDecl, GroupDecl, LeafDecl, ListDecl, Schema, SingleDecl, ZoneDecl } from '../elements'
 
@@ -20,7 +21,7 @@ export type Simplify<T> = { [K in keyof T]: T[K] } & {}
  */
 export type ZoneNode = ReactNode
 
-export type SingleDef<R = unknown> = { key: string; decl: Decl<R> }
+export type SingleDef<R = unknown> = { key: string; decl: Decl<R>; editor?: 'cms' | 'canvas' }
 export type Singles = Record<string, SingleDef>
 /**
  * An entry a collection starts with: its slug (also the key a seed's `{ $ref: { key } }` names it
@@ -45,6 +46,7 @@ export type Seo = { titleTemplate?: string; defaultImage?: string; organisation?
 
 export type Site = {
   knowledge?: KnowledgePolicyV1
+  forms?: FormDeclaration[]
   singles: Singles; collections: Record<string, CollectionDef>
   layouts: Record<string, { default: boolean; parent?: string; blocks: string[] }>
   pages: Record<string, { route: string; layout: string; blocks: ZoneDecl }>
@@ -53,6 +55,7 @@ export type Site = {
 }
 export type SiteManifest = {
   knowledge?: KnowledgePolicyV1
+  forms?: FormDeclaration[]
   schema: Schema
   layouts: Site['layouts']; pages: Site['pages']; pageTypes: Site['pageTypes']
   /** Each collection's declared seed entries, by collection name; collections that declare none are absent. */

package/src/site/version.ts

@@ -1 +1 @@
-export const SITE_KIT_VERSION = '1.6.4'
+export const SITE_KIT_VERSION = '1.6.6'

package/src/site/wire.ts

@@ -1,5 +1,6 @@
 import type { EntryRecord, FieldDecl, Id, MediaRecord, PageRecord } from '../elements'
 import type { SiteManifest } from './types'
+import type { PublishedCustomCode } from '../custom-code'
 
 /** A page's or an entry's SEO settings as the platform stores them. `ogImage` is a media id whose record is in the reply's `media`. */
 export type ReplySeo = { title: string | null; description: string | null; ogTitle: string | null; ogDescription: string | null; ogImage: Id | null; canonical: string | null; noindex: boolean }
@@ -84,6 +85,8 @@ export type SeoOrganisation = {
 
 /** The site-wide SEO settings, as `/site` answers them. */
 export type SiteReply = {
+  /** Public published snapshot only; drafts and attribution never cross this boundary. */
+  customCode?: PublishedCustomCode | null
   allowIndexing: boolean
   bingVerification: null | string
   description: null | string

package/src/features/client/ConsentRuntime.tsx

@@ -1,95 +0,0 @@
-'use client'
-import {
-  Suspense,
-  useCallback,
-  useLayoutEffect,
-  useMemo,
-  useRef,
-  useState,
-  type ReactNode,
-} from 'react'
-import type { PublicFeatureBase } from '../contracts'
-import { deniedConsentState } from '../contracts/consent'
-import type { CustomConsentRegistration } from '../consent/custom'
-import { consentRegistry } from '../consent/registry'
-import { ConsentContext } from './useConsent'
-import { PageReporter } from './PageReporter'
-const ignoreTitle = () => {}
-/** Commit-only ownership: rendering never installs listeners, scripts, or authority. */
-export function ConsentRuntime({
-  endpoint,
-  config,
-  customConsent,
-  children,
-}: {
-  endpoint: string
-  config: PublicFeatureBase | null
-  customConsent?: CustomConsentRegistration
-  children: ReactNode
-}) {
-  const owner = useRef({})
-  const registry = useRef<ReturnType<typeof consentRegistry> | null>(null)
-  const [snapshot, setSnapshot] = useState(() => ({
-    state: deniedConsentState(),
-    ready: false,
-    error: null as string | null,
-    reloadRequired: false,
-  }))
-  useLayoutEffect(() => {
-    const current = consentRegistry(window)
-    registry.current = current
-    const off = current.subscribe(() => setSnapshot(current.read()))
-    const currentOwner = owner.current
-    current.attach(currentOwner)
-    return () => {
-      off()
-      current.detach(currentOwner)
-      registry.current = null
-    }
-  }, [])
-  useLayoutEffect(() => {
-    registry.current!.commit(
-      owner.current,
-      endpoint,
-      config?.enabled.consent ?? false,
-      config?.consent,
-      customConsent,
-    )
-    setSnapshot(registry.current!.read())
-  }, [endpoint, config, customConsent, customConsent?.adapter, customConsent?.openPreferences])
-  const openPreferences = useCallback(() => registry.current?.openPreferences(), [])
-  const page = useCallback((path: string) => registry.current?.page(path), [])
-  const value = useMemo(
-    () => ({
-      state: snapshot.state,
-      ready: snapshot.ready,
-      error: snapshot.error,
-      openPreferences,
-    }),
-    [snapshot, openPreferences],
-  )
-  return (
-    <ConsentContext.Provider value={value}>
-      {children}
-      <Suspense fallback={null}>
-        <PageReporter report={page} titleChanged={ignoreTitle} />
-      </Suspense>
-      {snapshot.error && (
-        <div className="u90-features u90-consent-status">
-          <p role="status" aria-live="polite">
-            {snapshot.error}
-          </p>
-          {snapshot.reloadRequired ? (
-            <button type="button" data-u90-consent-reload onClick={() => window.location.reload()}>
-              Reload to apply consent changes
-            </button>
-          ) : (
-            <button type="button" onClick={() => registry.current?.retry()}>
-              Retry consent setup
-            </button>
-          )}
-        </div>
-      )}
-    </ConsentContext.Provider>
-  )
-}

package/src/features/client/useConsent.ts

@@ -1,15 +0,0 @@
-'use client'
-import { createContext, useContext } from 'react'
-import type { ConsentState } from '../contracts/consent'
-export type ConsentController = {
-  state: ConsentState
-  ready: boolean
-  error: string | null
-  openPreferences(): void
-}
-export const ConsentContext = createContext<ConsentController | null>(null)
-export function useConsent(): ConsentController {
-  const value = useContext(ConsentContext)
-  if (!value) throw new Error('Consent hooks require a SiteFeatures root.')
-  return value
-}

package/src/features/consent/README.md

@@ -1,70 +0,0 @@
-# Consent setup and lifecycle
-
-Install the existing same-origin feature gateway. Mount this standard setup once in the consuming server root layout, independently of whether Consent is currently enabled:
-
-```tsx
-import { SiteFeatures } from '@unitninety/site-kit/features'
-import { ConsentDefaults } from '@unitninety/site-kit/features/server'
-import '@unitninety/site-kit/features/styles.css'
-
-export default function RootLayout({ children }: { children: React.ReactNode }) {
-  return <html lang="en"><body>
-    <ConsentDefaults />
-    <SiteFeatures>{children}</SiteFeatures>
-  </body></html>
-}
-```
-
-Keep the root around children from their first render, including while choosing custom presentations. Remote accepted configuration controls activation, provider/source, Google mode and integrations. No installation, grant or mode prop is supported. Later administration does not require layout edits. Reuse the native gateway handlers; never add a competing catch-all.
-
-`ConsentDefaults` is exported only through the server entry. It renders a stable-ID denied-only `next/script` with `beforeInteractive`, without provider IDs, tag sources, configuration fetches or pageviews. Installed Next 16.3.4 queues App Router scripts before hydration; this does not promise native parser-time execution or control unmanaged async scripts. Remove old CMP, GA and other raw optional installers. The browser driver defensively runs the same initializer before its own first managed Google insertion if its marker is absent; conflicting unmanaged Google ownership aborts insertion. The marker is bookkeeping, never consent authority, and defaults never replay on refresh/navigation/regrant.
-
-`useConsent()` exposes exactly `{ state, ready, error, openPreferences }`. A real preferences button calls `openPreferences`; unavailable or throwing providers produce a handled error. The root supplies an accessible status/retry control and a visitor-controlled **Reload to apply consent changes** button when needed. It never reloads automatically on Close or assumes any event confirms a saved choice. Existing preferences controls remain usable during disable/withdrawal where the provider is still available.
-
-## Banner embed URL
-
-The Cookies workspace accepts an HTTPS script URL from any banner provider. With an active
-`custom` installation and no `customConsent` registration, Site Kit inserts that script once per
-document. No adapter or consent event is required just to display the provider's banner. The URL
-must point to its external JavaScript, not a provider dashboard, iframe page or pasted HTML. Providers
-that need inline initialization, extra attributes or synchronous parser execution may still need
-website code. The website Content Security Policy must allow the provider’s script origin and
-any additional resources it needs; saving a URL does not relax that policy. Custom script changes retain the existing `code.write` permission requirement.
-
-Embedding does not grant U90 consent: `useConsent().ready` stays false, all U90-managed optional
-integrations remain denied, and the provider's own controls handle preferences. Unregistered
-`u90:consent` events are ignored. Successful loading alone is not a consent signal. A missing optional
-registration is not an installation error; actual network failures/timeouts still surface normally.
-Already executed scripts cannot be undone by disabling the feature; reload the document to apply
-URL removal/replacement. Remove duplicate legacy installers before enabling the embed.
-
-Recognized direct CookieScript URLs retain their built-in category connection automatically. Other
-URLs use the same provider-independent embed path. Existing saved installations remain compatible.
-
-## Optional custom consent connection
-
-The optional `SiteFeatures` prop `customConsent?: CustomConsentRegistration` selects exactly one code-owned registration, only when the accepted remote provider is `custom`:
-
-```ts
-// Stable module identity, or useMemo with stable callback/adapter dependencies.
-const customConsent = { adapter: myConsentAdapter }
-// Alternatively: const customConsent = { openPreferences: reopenMyCMP }
-```
-
-The adapter supplies `read`, `subscribe` (returning cleanup) and `openPreferences`. The event bridge supplies only the reopen callback and publishes a fresh complete validated `ConsentState` in `window` event `u90:consent` during its active subscription. An event before registration cannot qualify. Missing/conflicting registration, invalid/unready snapshots and missing reopening deny optional code. An absent registration still permits the banner embed described above; an explicitly invalid registration remains an error. There is no arbitrary-window-global fallback. Factories are side-effect free; committed ownership subscribes before provider insertion and immediately reads current state.
-
-Keep actual adapter identity stable. For a bridge keep both its registration object and reopen callback stable. Replacement after activation requires a document reload and cannot transfer old events/grants. Render-only/suspended updates do not install listeners or replace authority.
-
-## Runtime guarantees and limits
-
-A document-owned registry retains execution records across navigation, React replay, root remount, integration removal and endpoint replacement. Equivalent settings revisions do not reinstall scripts or resubscribe. Last accepted config remains authoritative during failed/rejected refresh; real provider failures, committed disable and endpoint/provider replacement still deny immediately. Session/Feedback errors never decide consent. Disabled Consent does not grant categories.
-
-The fixed `createConsentLoader(driver)` API exposes `apply(state, integrations): Promise<void>` and `dispose(): void`. `IntegrationDriver` remains `start(integration): Promise<void>` and `stop(id): Promise<'stopped' | 'reload-required'>`. Starts deduplicate; withdrawal invokes stop immediately even during an unresolved start, and late initialization is stopped again. Built-in vetoes are synchronous. Drivers supplied by code must honor that same emission-veto obligation. Ten-second load/stop bounds surface failure and uncertainty. A network load error is retryable; possibly executing timed-out code requires reload.
-
-Basic Google mode makes no managed Google tag request before consent. Explicit advanced mode permits only classified Google requests while denied and may produce vendor consent-mode traffic; generic rows remain category-gated. Google defaults/update, `ga-disable`, `send_page_view:false` and current-permission checks guard Site Kit-owned SPA pageviews. Denied queued navigation is discarded; regrant emits only the current page.
-
-The shared closed classifier determines new GA4/ContentSquare drivers and approved executable attributes. An already executed GA source retains its proven teardown on category-policy changes, but its events require **both current row-category permission and analytics consent**. That historical capability never changes classification, code.write authorization or advanced eligibility for the edited row. New recategorized rows are generic.
-
-ContentSquare uses documented `optout` and requires reload; no web optin or cookie-clearing workaround is supplied. Its persisted opt-out may still affect regrant after reload. Attempted generic/Maps code requires reload regardless of a requested `stop` policy. Removing a script node is not teardown. Any reload requirement blocks every optional restart, including renamed/readded rows, until a real document reload. Previously executed third-party code cannot be rolled back.
-
-Tests use deterministic local DOM/provider doubles only. Task3 supplies actual production Next browser tag/beacon proof, both public projections, settings authorization/UI, the standard starter mount and exact KAW fixture transforms. No live-vendor account, regional/legal compliance, ContentSquare delivery/regrant or production rollout is certified.

package/src/features/consent/cookieScript.ts

@@ -1,53 +0,0 @@
-import { deniedConsentState, type ConsentAdapter, type ConsentState } from '../contracts/consent'
-
-/** Provider state is authoritative; neither event names nor an action alone grant categories. */
-export function normalizeCookieScript(input: unknown): ConsentState {
-  if (!input || typeof input !== 'object') return deniedConsentState()
-  const state = input as { action?: unknown; categories?: unknown }
-  if ((state.action !== 'accept' && state.action !== 'reject') || !Array.isArray(state.categories) ||
-    !state.categories.every((category) => typeof category === 'string')) return deniedConsentState()
-  const accepted = state.action === 'accept' ? state.categories : []
-  return {
-    version: 1, necessary: true, ready: true,
-    preferences: accepted.includes('functionality'), analytics: accepted.includes('performance'),
-    marketing: accepted.includes('targeting'),
-  }
-}
-
-type CookieScriptWindow = Window & { CookieScript?: { instance?: { currentState?: () => unknown; show?: () => void } } }
-const EVENTS = ['CookieScriptLoaded', 'CookieScriptAccept', 'CookieScriptAcceptAll', 'CookieScriptReject', 'CookieScriptClose'] as const
-
-/** Construct without side effects; the root subscribes before installing its owned CMP. */
-export function cookieScriptAdapter(window: Window): ConsentAdapter {
-  const target = window as CookieScriptWindow
-  const listeners = new Set<(state: ConsentState) => void>()
-  let reopenFailed = false
-  const read = (): ConsentState => {
-    try {
-      const instance = target.CookieScript?.instance
-      if (reopenFailed || typeof instance?.currentState !== 'function' || typeof instance.show !== 'function') return deniedConsentState()
-      return normalizeCookieScript(instance.currentState())
-    } catch { return deniedConsentState() }
-  }
-  const publish = () => { const state = read(); for (const listener of listeners) listener({ ...state }) }
-  const change = () => { reopenFailed = false; publish() }
-  return {
-    read,
-    subscribe(listener) {
-      if (listeners.size === 0) for (const event of EVENTS) window.addEventListener(event, change)
-      listeners.add(listener)
-      let subscribed = true
-      return () => {
-        if (!subscribed) return
-        subscribed = false
-        listeners.delete(listener)
-        if (listeners.size === 0) for (const event of EVENTS) window.removeEventListener(event, change)
-      }
-    },
-    openPreferences() {
-      if (!read().ready) { publish(); return }
-      try { target.CookieScript!.instance!.show!() }
-      catch { reopenFailed = true; publish() }
-    },
-  }
-}

package/src/features/consent/custom.ts

@@ -1,89 +0,0 @@
-import { ConsentStateSchema, deniedConsentState, type ConsentAdapter, type ConsentState } from '../contracts/consent'
-
-/** Code-owned registration: choose one stable adapter or one normalized-event bridge. */
-export type CustomConsentRegistration =
-  | { adapter: ConsentAdapter; openPreferences?: never }
-  | { adapter?: never; openPreferences: () => void }
-
-export function customConsentAdapter(window: Window, registration?: CustomConsentRegistration): ConsentAdapter {
-  const listeners = new Set<(state: ConsentState) => void>()
-  const adapter = registration?.adapter
-  const registered = adapter && registration.openPreferences === undefined &&
-    typeof adapter.read === 'function' && typeof adapter.subscribe === 'function' && typeof adapter.openPreferences === 'function'
-  const reopen = registration?.openPreferences
-  const bridge = adapter === undefined && typeof registration?.openPreferences === 'function'
-  let state = deniedConsentState()
-  let failed = false
-  let subscription = 0
-  const hasReopen = () => registered
-    ? registration?.adapter === adapter && registration.openPreferences === undefined && typeof adapter.openPreferences === 'function'
-    : bridge && registration?.adapter === undefined && typeof reopen === 'function' && registration?.openPreferences === reopen
-  let cleanup: (() => void) | undefined
-  const normalize = (input: unknown): ConsentState => {
-    try {
-      const result = ConsentStateSchema.safeParse(input)
-      return result.success ? result.data : deniedConsentState()
-    } catch { return deniedConsentState() }
-  }
-  const publish = (input: unknown) => {
-    state = normalize(input)
-    for (const listener of listeners) listener({ ...state })
-  }
-  const change = (event: Event) => { failed = false; publish(hasReopen() ? (event as CustomEvent<unknown>).detail : deniedConsentState()) }
-  const read = (): ConsentState => {
-    if (failed || !hasReopen()) return deniedConsentState()
-    if (registered) {
-      try { state = normalize(adapter.read()); return { ...state } }
-      catch { state = deniedConsentState(); return { ...state } }
-    }
-    return bridge && listeners.size > 0 ? { ...state } : deniedConsentState()
-  }
-  return {
-    read,
-    subscribe(listener) {
-      listeners.add(listener)
-      if (listeners.size === 1) {
-        const current = ++subscription
-        state = deniedConsentState()
-        failed = false
-        if (registered) {
-          try {
-            let active = false
-            const off = adapter.subscribe((next) => {
-              if (!active || current !== subscription || !listeners.size) return
-              failed = false
-              publish(hasReopen() ? next : deniedConsentState())
-            })
-            if (typeof off !== 'function') throw new Error('Custom subscription must supply cleanup.')
-            active = true
-            cleanup = off
-            publish(read())
-          } catch { ++subscription; failed = true; publish(deniedConsentState()) }
-        } else if (bridge) {
-          window.addEventListener('u90:consent', change)
-          cleanup = () => window.removeEventListener('u90:consent', change)
-        }
-      }
-      let subscribed = true
-      return () => {
-        if (!subscribed) return
-        subscribed = false
-        listeners.delete(listener)
-        if (listeners.size === 0) {
-          ++subscription
-          try { cleanup?.() } catch { /* Detached listeners cannot restore this authority. */ }
-          cleanup = undefined
-          state = deniedConsentState()
-          failed = true
-        }
-      }
-    },
-    openPreferences() {
-      if (!read().ready) { publish(deniedConsentState()); return }
-      try {
-        if (registered) adapter.openPreferences()
-        else if (bridge) reopen!()
-      } catch { failed = true; publish(deniedConsentState()) }
-    },
-  }
-}

package/src/features/consent/defaults.ts

@@ -1,40 +0,0 @@
-/** Shared server/bootstrap and defensive driver initializer. No tenant/category authority. */
-export type GoogleConsentWindow = Window & {
-  __u90ConsentDefaultsV1?: true
-  dataLayer?: unknown[]
-  gtag?: (...args: unknown[]) => void
-}
-export function initializeConsentDefaults(window: Window): void {
-  const target = window as GoogleConsentWindow
-  if (target.__u90ConsentDefaultsV1 === true) {
-    if (!Array.isArray(target.dataLayer) || typeof target.gtag !== 'function')
-      throw new Error('Consent defaults are unavailable.')
-    return
-  }
-  if (
-    target.gtag !== undefined ||
-    (target.dataLayer !== undefined &&
-      (!Array.isArray(target.dataLayer) || target.dataLayer.length > 0))
-  )
-    throw new Error(
-      'Consent defaults ownership conflicts with unmanaged Google code. Reload after correcting setup.',
-    )
-  target.dataLayer = target.dataLayer || []
-  target.gtag = function () {
-    // Preserve Google's documented gtag queue payload shape.
-    // eslint-disable-next-line prefer-rest-params
-    target.dataLayer!.push(arguments)
-  }
-  target.gtag('consent', 'default', {
-    analytics_storage: 'denied',
-    ad_storage: 'denied',
-    ad_user_data: 'denied',
-    ad_personalization: 'denied',
-    functionality_storage: 'denied',
-    personalization_storage: 'denied',
-    security_storage: 'granted',
-  })
-  target.__u90ConsentDefaultsV1 = true
-}
-export const CONSENT_DEFAULTS_ID = 'u90-consent-defaults-v1'
-export const CONSENT_DEFAULTS_SCRIPT = `(${initializeConsentDefaults.toString()})(window);`