@saena-io/content 0.1.0 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saena-io/content",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -21,8 +21,8 @@
     "clean": "rm -rf dist .turbo"
   },
   "dependencies": {
-    "@saena-io/plugin-sdk": "workspace:*",
-    "@saena-io/ui": "workspace:*",
+    "@saena-io/plugin-sdk": "^0.1.0",
+    "@saena-io/ui": "^0.1.1",
     "drizzle-orm": "^0.45.2",
     "react": "^19.2.6",
     "zod": "^4.4.3"
@@ -31,10 +31,7 @@
     "@types/react": "^19",
     "drizzle-kit": "^0.31.10"
   },
-  "files": [
-    "src",
-    "drizzle"
-  ],
+  "files": ["src", "drizzle"],
   "publishConfig": {
     "access": "public"
   }

package/src/admin/field-registry.tsx

@@ -1,5 +1,6 @@
 import type { ReactNode } from 'react';
 import type { FieldDecl, FieldPath } from '../field';
+import { singletonMap } from '../singleton';
 
 // The React half of the field-type registry: a field-type id → its admin editor. Built-in editors register on
 // import (./editors); custom field types register their editor the same way. The form engine renders
@@ -21,7 +22,7 @@ export interface AdminEditorProps<S = unknown> {
 }
 export type AdminEditor<S = unknown> = (props: AdminEditorProps<S>) => ReactNode;
 
-const editors = new Map<string, AdminEditor>();
+const editors = singletonMap<string, AdminEditor>('content.editors');
 
 /** Register the admin editor for a field-type id (built-in or custom). */
 export function registerEditor<S>(id: string, editor: AdminEditor<S>): void {

package/src/define.ts

@@ -1,4 +1,5 @@
 import type { FieldDecl, InferValue } from './field';
+import { singletonMap } from './singleton';
 
 // Section + page DEFINITIONS — the React-free half of "structure is code" (ADR-0008). A section author declares
 // a section's id, label, and field schema here (the schema drives admin form + validation + i18n + the public
@@ -11,7 +12,7 @@ export interface SectionDef<S extends FieldDecl = FieldDecl> {
   schema: S;
 }
 
-const sections = new Map<string, SectionDef>();
+const sections = singletonMap<string, SectionDef>('content.sections');
 
 /** Declare a content section's schema (registers it for the admin form, the server service, and key derivation). */
 export function defineSection<S extends FieldDecl>(def: SectionDef<S>): SectionDef<S> {
@@ -45,7 +46,7 @@ export interface CollectionDef<S extends FieldDecl = FieldDecl> {
   slug?: { from?: string };
 }
 
-const collections = new Map<string, CollectionDef>();
+const collections = singletonMap<string, CollectionDef>('content.collections');
 
 /** Declare a routed collection (registers it for the admin manager, the server service, and key derivation). */
 export function defineCollection<S extends FieldDecl>(def: CollectionDef<S>): CollectionDef<S> {
@@ -76,7 +77,7 @@ export interface PageDef {
   sections: string[];
 }
 
-const pages = new Map<string, PageDef>();
+const pages = singletonMap<string, PageDef>('content.pages');
 
 /** Declare a page as a fixed, ordered composition of sections (the admin reads this tree read-only). */
 export function definePage(def: PageDef): PageDef {

package/src/field/registry.ts

@@ -1,3 +1,4 @@
+import { singletonMap } from '../singleton';
 import type { FieldDecl, FieldType } from './types';
 
 // The React-free field-type registry: id → runtime behaviour (empty/validate/leaves/hydrate). Built-ins
@@ -5,7 +6,7 @@ import type { FieldDecl, FieldType } from './types';
 // through `fieldType(id)`, so the whole schema tree is traversable from any value. The React editor registry
 // (id → AdminEditor) is a separate, parallel map in ../admin — same id, different world.
 
-const registry = new Map<string, FieldType>();
+const registry = singletonMap<string, FieldType>('content.fieldTypes');
 
 /** Register a field type's runtime behaviour. Idempotent by id (last registration wins). */
 export function registerFieldType(type: FieldType): void {

package/src/public/index.tsx

@@ -2,6 +2,7 @@ import { type AssetRef, IMAGE_WIDTH_LADDER } from '@saena-io/plugin-sdk';
 import { RichTextStatic } from '@saena-io/ui/components/rich-text/static';
 import type { ComponentType } from 'react';
 import type { ImageValue } from '../field';
+import { singletonMap } from '../singleton';
 
 // @saena-io/content/public — the public-site readers a section's React component uses to render field values.
 // Editor-free (RichTextStatic ships no editor), so the public bundle stays editor-free (ADR-0005/0008). v1
@@ -120,7 +121,7 @@ export function ContentImage({
 /** A section's public component — receives its hydrated `content`. */
 export type SectionComponent<C = unknown> = ComponentType<{ content: C }>;
 
-const sectionComponents = new Map<string, SectionComponent>();
+const sectionComponents = singletonMap<string, SectionComponent>('content.sectionComponents');
 
 /** Register a section's public component by id (call once at module load, alongside the component). */
 export function registerSectionComponent<C>(id: string, component: SectionComponent<C>): void {

package/src/singleton.ts

@@ -0,0 +1,32 @@
+// A process-wide singleton Map, keyed by name on globalThis.
+//
+// Why: content's registries (sections/pages/collections, field types, editors, section components) are
+// declared as module-local `Map`s and shared across this package's entry points (`./define`, `./admin`,
+// `./public`, `./field`). In the monorepo (symlinked source) every importer resolves to one module
+// instance, so a plain `const m = new Map()` is fine. But when @saena-io/content is consumed as a
+// PUBLISHED dependency, a registry written via the package's subpath export (e.g. the app calling
+// `definePage` from `@saena-io/content/define`) and read via the package's INTERNAL relative import
+// (e.g. `buildContentAdmin` reading `allPages` from `../define`) can resolve to two distinct module
+// instances → two separate Maps → the app's registrations are invisible to the admin/public readers
+// (no Content nav, "Screen not found", blank live preview).
+//
+// Anchoring the Map on `globalThis` makes it immune to that duplication: however many times this module
+// is instantiated, every copy reads/writes the same underlying Map. (SSR and the browser have separate
+// globals, which is correct — each side registers and reads within its own runtime.)
+
+const NS = '__saenaContentRegistries__';
+
+type Store = Record<string, Map<unknown, unknown>>;
+
+function store(): Store {
+  const g = globalThis as unknown as { [NS]?: Store };
+  if (!g[NS]) g[NS] = {};
+  return g[NS];
+}
+
+/** Get the process-wide Map registered under `key`, creating it once. */
+export function singletonMap<K, V>(key: string): Map<K, V> {
+  const s = store();
+  if (!s[key]) s[key] = new Map();
+  return s[key] as Map<K, V>;
+}