@wular/pnext 0.0.4 → 0.0.7

package/src/utils/serialize.ts

@@ -3,22 +3,22 @@
 // as the action wire's $$pnext_date) instead of throwing; the client/server
 // revive the marker back into the original view. assertSerializable accepts
 // them (they are "serializable" via the marker path) rather than rejecting.
-const TYPED_ARRAY_MARKER = '$$pnext_typed_array';
-const ARRAY_BUFFER_MARKER = '$$pnext_array_buffer';
+const TYPED_ARRAY_MARKER = '$$pnext_typed_array'
+const ARRAY_BUFFER_MARKER = '$$pnext_array_buffer'
 // Map/Set are part of React's flight wire vocabulary (client components can receive them as props); pnext
 // does not stream them as distinct RSC row types yet, so they ride as ordinary marker objects, entries
 // encoded recursively like the binary markers above, instead of throwing "must be a plain object". Client
 // code that only round-trips the value sees a marker object rather than a live Map/Set instance - a known
 // gap, not a full flight-protocol Map/Set.
-const MAP_MARKER = '$$pnext_map';
-const SET_MARKER = '$$pnext_set';
+const MAP_MARKER = '$$pnext_map'
+const SET_MARKER = '$$pnext_set'
 // Cyclic props (a client component receiving `obj.self === obj`) are part of React's flight vocabulary:
 // flight emits a BACK-REFERENCE to the row/path the value was first written at rather than expanding it
 // forever. Same idea here, scoped to the ancestor chain: an object that reappears INSIDE ITSELF is written as
 // `{$$pnext_ref: [...path from the props root]}` and the client patches the original object back in,
 // restoring identity. Only true cycles are encoded this way - a value that merely appears twice in different
 // branches is still expanded, so every acyclic payload is byte-identical to what it was before.
-const REF_MARKER = '$$pnext_ref';
+const REF_MARKER = '$$pnext_ref'
 
 type TypedArray =
   | Int8Array
@@ -31,26 +31,26 @@ type TypedArray =
   | Float32Array
   | Float64Array
   | BigInt64Array
-  | BigUint64Array;
+  | BigUint64Array
 
 function isTypedArray(value: unknown): value is TypedArray {
-  return ArrayBuffer.isView(value) && !(value instanceof DataView);
+  return ArrayBuffer.isView(value) && !(value instanceof DataView)
 }
 
 function bytesToBase64(bytes: Uint8Array): string {
-  if (typeof Buffer !== 'undefined') return Buffer.from(bytes).toString('base64');
-  let binary = '';
-  for (const byte of bytes) binary += String.fromCharCode(byte);
-  return btoa(binary);
+  if (typeof Buffer !== 'undefined') return Buffer.from(bytes).toString('base64')
+  let binary = ''
+  for (const byte of bytes) binary += String.fromCharCode(byte)
+  return btoa(binary)
 }
 
 function encodeTypedArray(value: TypedArray) {
-  const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
-  return { [TYPED_ARRAY_MARKER]: { type: value.constructor.name, data: bytesToBase64(bytes) } };
+  const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength)
+  return { [TYPED_ARRAY_MARKER]: { type: value.constructor.name, data: bytesToBase64(bytes) } }
 }
 
 function encodeArrayBuffer(value: ArrayBuffer) {
-  return { [ARRAY_BUFFER_MARKER]: bytesToBase64(new Uint8Array(value)) };
+  return { [ARRAY_BUFFER_MARKER]: bytesToBase64(new Uint8Array(value)) }
 }
 
 /**
@@ -66,24 +66,20 @@ function encodeBinary(
   ancestors = new Map<object, string[]>(),
   path: string[] = [],
 ): unknown {
-  if (value === null || typeof value !== 'object') return value;
-  if (isTypedArray(value)) return encodeTypedArray(value);
-  if (value instanceof ArrayBuffer) return encodeArrayBuffer(value);
-  const ancestorPath = ancestors.get(value);
-  if (ancestorPath) return { [REF_MARKER]: ancestorPath };
-  ancestors.set(value, path);
-  const encoded = encodeContainer(value, ancestors, path);
-  ancestors.delete(value);
-  return encoded;
+  if (value === null || typeof value !== 'object') return value
+  if (isTypedArray(value)) return encodeTypedArray(value)
+  if (value instanceof ArrayBuffer) return encodeArrayBuffer(value)
+  const ancestorPath = ancestors.get(value)
+  if (ancestorPath) return { [REF_MARKER]: ancestorPath }
+  ancestors.set(value, path)
+  const encoded = encodeContainer(value, ancestors, path)
+  ancestors.delete(value)
+  return encoded
 }
 
-function encodeContainer(
-  value: object,
-  ancestors: Map<object, string[]>,
-  path: string[],
-): unknown {
+function encodeContainer(value: object, ancestors: Map<object, string[]>, path: string[]): unknown {
   if (Array.isArray(value)) {
-    return value.map((item, index) => encodeBinary(item, ancestors, [...path, String(index)]));
+    return value.map((item, index) => encodeBinary(item, ancestors, [...path, String(index)]))
   }
   if (value instanceof Map) {
     return {
@@ -91,22 +87,22 @@ function encodeContainer(
         encodeBinary(k, ancestors),
         encodeBinary(v, ancestors),
       ]),
-    };
+    }
   }
   if (value instanceof Set) {
-    return { [SET_MARKER]: [...value].map(item => encodeBinary(item, ancestors)) };
+    return { [SET_MARKER]: [...value].map(item => encodeBinary(item, ancestors)) }
   }
-  if (Object.getPrototypeOf(value) !== Object.prototype) return value;
-  const out: Record<string, unknown> = {};
+  if (Object.getPrototypeOf(value) !== Object.prototype) return value
+  const out: Record<string, unknown> = {}
   for (const [key, item] of Object.entries(value)) {
-    out[key] = encodeBinary(item, ancestors, [...path, key]);
+    out[key] = encodeBinary(item, ancestors, [...path, key])
   }
-  return out;
+  return out
 }
 
 // Errors reach `error.tsx` as props and ride the same marker convention (the
 // encoder for this one lives on the render side, with the boundary props).
-const ERROR_MARKER = '$$pnextError';
+const ERROR_MARKER = '$$pnextError'
 
 /**
  * Revive the wire markers `serializeProps` wrote, IN PLACE:
@@ -124,22 +120,22 @@ export function reviveSerializedRefs<T>(
   root: T,
   extra?: (node: Record<string, unknown>) => unknown,
 ): T {
-  if (root === null || typeof root !== 'object') return root;
+  if (root === null || typeof root !== 'object') return root
   const visit = (node: Record<string, unknown>): void => {
     for (const key of Object.keys(node)) {
-      const item = node[key];
-      if (item === null || typeof item !== 'object' || ArrayBuffer.isView(item)) continue;
-      const child = item as Record<string, unknown>;
-      const revived = refTarget(root, child) ?? extra?.(child) ?? binaryTarget(child);
+      const item = node[key]
+      if (item === null || typeof item !== 'object' || ArrayBuffer.isView(item)) continue
+      const child = item as Record<string, unknown>
+      const revived = refTarget(root, child) ?? extra?.(child) ?? binaryTarget(child)
       if (revived !== undefined) {
-        node[key] = revived;
-        continue;
+        node[key] = revived
+        continue
       }
-      visit(child);
+      visit(child)
     }
-  };
-  visit(root as Record<string, unknown>);
-  return root;
+  }
+  visit(root as Record<string, unknown>)
+  return root
 }
 
 /**
@@ -149,17 +145,17 @@ export function reviveSerializedRefs<T>(
  * untouched when compat is off), and only compat entries import this name.
  */
 export function reviveSerializedErrorRefs<T>(root: T): T {
-  return reviveSerializedRefs(root, errorTarget);
+  return reviveSerializedRefs(root, errorTarget)
 }
 
 function errorTarget(node: Record<string, unknown>): Error | undefined {
-  const marker = node[ERROR_MARKER];
-  if (marker === null || typeof marker !== 'object') return undefined;
-  const data = marker as { name?: unknown; message?: unknown; digest?: unknown };
-  const error = new Error(typeof data.message === 'string' ? data.message : '');
-  if (typeof data.name === 'string') error.name = data.name;
-  if (typeof data.digest === 'string') (error as Error & { digest?: string }).digest = data.digest;
-  return error;
+  const marker = node[ERROR_MARKER]
+  if (marker === null || typeof marker !== 'object') return undefined
+  const data = marker as { name?: unknown; message?: unknown; digest?: unknown }
+  const error = new Error(typeof data.message === 'string' ? data.message : '')
+  if (typeof data.name === 'string') error.name = data.name
+  if (typeof data.digest === 'string') (error as Error & { digest?: string }).digest = data.digest
+  return error
 }
 
 // The wire carries the view's constructor NAME. Resolved off the global rather than a name-to-constructor
@@ -167,48 +163,48 @@ function errorTarget(node: Record<string, unknown>): Error | undefined {
 // so any other name - including one that resolves to something else entirely - resolves to undefined and the
 // marker is left alone.
 function typedArrayConstructor(name: string) {
-  const constructor = (globalThis as unknown as Record<string, unknown>)[name];
+  const constructor = (globalThis as unknown as Record<string, unknown>)[name]
   return typeof constructor === 'function' && 'BYTES_PER_ELEMENT' in constructor
     ? (constructor as unknown as new (buffer: ArrayBuffer) => TypedArray)
-    : undefined;
+    : undefined
 }
 
 // Decode side is client-only (the encoder is what runs on the server), so no
 // Buffer fast path — `atob` is global in every runtime that reaches this.
 function base64ToBytes(data: string): Uint8Array {
-  return Uint8Array.from(atob(data), character => character.charCodeAt(0));
+  return Uint8Array.from(atob(data), character => character.charCodeAt(0))
 }
 
 function binaryTarget(node: Record<string, unknown>): TypedArray | ArrayBuffer | undefined {
-  const buffer = node[ARRAY_BUFFER_MARKER];
-  if (typeof buffer === 'string') return base64ToBytes(buffer).buffer as ArrayBuffer;
-  const typed = node[TYPED_ARRAY_MARKER];
-  if (typed === null || typeof typed !== 'object') return undefined;
-  const { type, data } = typed as { type?: unknown; data?: unknown };
-  if (typeof type !== 'string' || typeof data !== 'string') return undefined;
-  const Constructor = typedArrayConstructor(type);
-  return Constructor ? new Constructor(base64ToBytes(data).buffer as ArrayBuffer) : undefined;
+  const buffer = node[ARRAY_BUFFER_MARKER]
+  if (typeof buffer === 'string') return base64ToBytes(buffer).buffer as ArrayBuffer
+  const typed = node[TYPED_ARRAY_MARKER]
+  if (typed === null || typeof typed !== 'object') return undefined
+  const { type, data } = typed as { type?: unknown; data?: unknown }
+  if (typeof type !== 'string' || typeof data !== 'string') return undefined
+  const Constructor = typedArrayConstructor(type)
+  return Constructor ? new Constructor(base64ToBytes(data).buffer as ArrayBuffer) : undefined
 }
 
 function refTarget(root: unknown, node: Record<string, unknown>): unknown {
-  const path = node[REF_MARKER];
-  if (!Array.isArray(path)) return undefined;
-  let current: unknown = root;
+  const path = node[REF_MARKER]
+  if (!Array.isArray(path)) return undefined
+  let current: unknown = root
   for (const key of path) {
-    if (current === null || typeof current !== 'object') return undefined;
-    current = (current as Record<string, unknown>)[String(key)];
+    if (current === null || typeof current !== 'object') return undefined
+    current = (current as Record<string, unknown>)[String(key)]
   }
-  return current;
+  return current
 }
 
 /** A preact vnode: `h` sets `constructor` to undefined on every one it makes. */
 export function isElementLike(value: unknown): boolean {
-  if (value === null || typeof value !== 'object') return false;
+  if (value === null || typeof value !== 'object') return false
   return (
     (value as { constructor?: unknown }).constructor === undefined &&
     'type' in value &&
     'props' in value
-  );
+  )
 }
 
 export function assertSerializable(
@@ -219,59 +215,59 @@ export function assertSerializable(
   // static-slots), so they are serializable there. Server-action args/returns keep throwing.
   allowElements = false,
 ) {
-  if (value == null) return;
-  if (allowElements && isElementLike(value)) return;
-  const type = typeof value;
-  if (type === 'string' || type === 'number' || type === 'boolean') return;
+  if (value == null) return
+  if (allowElements && isElementLike(value)) return
+  const type = typeof value
+  if (type === 'string' || type === 'number' || type === 'boolean') return
   if (type === 'function' || type === 'symbol' || type === 'bigint' || type === 'undefined') {
-    throw new Error(`${path} is not serializable: ${type}`);
+    throw new Error(`${path} is not serializable: ${type}`)
   }
   // Typed arrays / ArrayBuffers are serializable via the binary marker path.
-  if (isTypedArray(value) || value instanceof ArrayBuffer) return;
+  if (isTypedArray(value) || value instanceof ArrayBuffer) return
   if (value instanceof Date || value instanceof URL) {
-    throw new Error(`${path} must be a plain JSON value`);
+    throw new Error(`${path} must be a plain JSON value`)
   }
-  if (typeof value !== 'object') return;
+  if (typeof value !== 'object') return
   // A value that contains ITSELF is serializable: encodeBinary writes it as a
   // `$$pnext_ref` back-reference (React flight does the same), so stop walking
   // rather than rejecting the props.
-  if (seen.has(value)) return;
-  seen.add(value);
+  if (seen.has(value)) return
+  seen.add(value)
 
   if (Array.isArray(value)) {
     value.forEach((item, index) =>
       assertSerializable(item, `${path}[${index}]`, seen, allowElements),
-    );
-    return;
+    )
+    return
   }
 
-  // The slot walk (islands/static-slots) never enters Map/Set, so elements inside them must
+  // The slot walk (render/static-slots) never enters Map/Set, so elements inside them must
   // still throw rather than ship mangled.
   if (value instanceof Map) {
-    let index = 0;
+    let index = 0
     for (const [key, item] of value.entries()) {
-      assertSerializable(key, `${path}<Map key ${index}>`, seen);
-      assertSerializable(item, `${path}<Map value ${index}>`, seen);
-      index++;
+      assertSerializable(key, `${path}<Map key ${index}>`, seen)
+      assertSerializable(item, `${path}<Map value ${index}>`, seen)
+      index++
     }
-    return;
+    return
   }
 
   if (value instanceof Set) {
-    let index = 0;
+    let index = 0
     for (const item of value) {
-      assertSerializable(item, `${path}<Set item ${index}>`, seen);
-      index++;
+      assertSerializable(item, `${path}<Set item ${index}>`, seen)
+      index++
     }
-    return;
+    return
   }
 
   if (Object.getPrototypeOf(value) !== Object.prototype) {
-    throw new Error(`${path} must be a plain object`);
+    throw new Error(`${path} must be a plain object`)
   }
 
   for (const [key, item] of Object.entries(value)) {
-    assertSerializable(item, `${path}.${key}`, seen, allowElements);
+    assertSerializable(item, `${path}.${key}`, seen, allowElements)
   }
 }
 
@@ -291,26 +287,26 @@ export function assertSerializable(
 // original) must not split the tainted set.
 // ---------------------------------------------------------------------------
 
-const TAINT_REGISTRY_KEY = '__pnext_tainted_values__';
+const TAINT_REGISTRY_KEY = '__pnext_tainted_values__'
 
 /** Dev message plus the redacted text prod shows in its place. */
 export interface TaintMessages {
-  dev: string;
-  prod: string;
+  dev: string
+  prod: string
 }
 
 function taintRegistry(): Map<object, TaintMessages> {
-  const host = globalThis as { [TAINT_REGISTRY_KEY]?: Map<object, TaintMessages> };
-  const existing = host[TAINT_REGISTRY_KEY];
-  if (existing) return existing;
-  const created = new Map<object, TaintMessages>();
-  host[TAINT_REGISTRY_KEY] = created;
-  return created;
+  const host = globalThis as { [TAINT_REGISTRY_KEY]?: Map<object, TaintMessages> }
+  const existing = host[TAINT_REGISTRY_KEY]
+  if (existing) return existing
+  const created = new Map<object, TaintMessages>()
+  host[TAINT_REGISTRY_KEY] = created
+  return created
 }
 
 /** Register `value` as unsafe to pass to a client component. */
 export function taintObjectReference(messages: TaintMessages, value: object): void {
-  taintRegistry().set(value, messages);
+  taintRegistry().set(value, messages)
 }
 
 /**
@@ -319,60 +315,57 @@ export function taintObjectReference(messages: TaintMessages, value: object): vo
  * identity the check relies on).
  */
 export function assertNotTainted(value: unknown, seen = new Set<unknown>()): void {
-  const registry = taintRegistry();
-  if (registry.size === 0) return;
-  if (value === null || typeof value !== 'object') return;
-  const messages = registry.get(value);
+  const registry = taintRegistry()
+  if (registry.size === 0) return
+  if (value === null || typeof value !== 'object') return
+  const messages = registry.get(value)
   if (messages !== undefined) {
     // Next surfaces the explanatory message in dev only; prod renders React's
     // redacted RSC error text in the nearest error boundary.
     throw new Error(
       // eslint-disable-next-line turbo/no-undeclared-env-vars
       process.env.NODE_ENV === 'development' ? messages.dev : messages.prod,
-    );
+    )
   }
-  if (seen.has(value)) return;
-  seen.add(value);
+  if (seen.has(value)) return
+  seen.add(value)
   if (Array.isArray(value)) {
-    for (const item of value) assertNotTainted(item, seen);
-    return;
+    for (const item of value) assertNotTainted(item, seen)
+    return
   }
   if (value instanceof Map) {
     for (const [key, item] of value.entries()) {
-      assertNotTainted(key, seen);
-      assertNotTainted(item, seen);
+      assertNotTainted(key, seen)
+      assertNotTainted(item, seen)
     }
-    return;
+    return
   }
   if (value instanceof Set) {
-    for (const item of value) assertNotTainted(item, seen);
-    return;
+    for (const item of value) assertNotTainted(item, seen)
+    return
   }
-  const proto = Object.getPrototypeOf(value) as object | null;
-  if (proto !== Object.prototype && proto !== null) return;
-  for (const item of Object.values(value)) assertNotTainted(item, seen);
+  const proto = Object.getPrototypeOf(value) as object | null
+  if (proto !== Object.prototype && proto !== null) return
+  for (const item of Object.values(value)) assertNotTainted(item, seen)
 }
 
 export function serializeProps(value: unknown, options?: { allowElements?: boolean }) {
-  assertNotTainted(value);
-  assertSerializable(value, 'props', new Set(), options?.allowElements);
-  return JSON.stringify(encodeBinary(value)).replace(
-    /[<>&\u2028\u2029]/g,
-    char => {
-      switch (char) {
-        case '<':
-          return '\\u003c';
-        case '>':
-          return '\\u003e';
-        case '&':
-          return '\\u0026';
-        case '\u2028':
-          return '\\u2028';
-        case '\u2029':
-          return '\\u2029';
-        default:
-          return char;
-      }
-    },
-  );
+  assertNotTainted(value)
+  assertSerializable(value, 'props', new Set(), options?.allowElements)
+  return JSON.stringify(encodeBinary(value)).replace(/[<>&\u2028\u2029]/g, char => {
+    switch (char) {
+      case '<':
+        return '\\u003c'
+      case '>':
+        return '\\u003e'
+      case '&':
+        return '\\u0026'
+      case '\u2028':
+        return '\\u2028'
+      case '\u2029':
+        return '\\u2029'
+      default:
+        return char
+    }
+  })
 }

package/src/utils/verbose.ts

@@ -1,39 +1,39 @@
-import { dim } from './ansi';
+import { dim } from './ansi'
 
 export interface VerboseLogger {
-  readonly enabled: boolean;
-  log(message: string): void;
-  step<T>(label: string, task: () => Promise<T>): Promise<T>;
+  readonly enabled: boolean
+  log(message: string): void
+  step<T>(label: string, task: () => Promise<T>): Promise<T>
 }
 
 export function createVerboseLogger(enabled: boolean, scope: string): VerboseLogger {
-  const prefix = dim(`pnext ${scope}`);
+  const prefix = dim(`pnext ${scope}`)
   // Stamp every line with time-since-process-start: once stages run in
   // parallel their lines interleave, and only the stamps say what overlapped.
   const write = (message: string) =>
-    console.log(`${prefix} ${dim(`@${(performance.now() / 1000).toFixed(2)}s`)} ${message}`);
+    console.log(`${prefix} ${dim(`@${(performance.now() / 1000).toFixed(2)}s`)} ${message}`)
 
   return {
     enabled,
     log(message) {
-      if (enabled) write(message);
+      if (enabled) write(message)
     },
     async step(label, task) {
-      if (!enabled) return task();
-      write(label);
-      const start = performance.now();
+      if (!enabled) return task()
+      write(label)
+      const start = performance.now()
       try {
-        return await task();
+        return await task()
       } finally {
-        write(`  ${dim(`↳ ${label} ${formatDuration(performance.now() - start)}`)}`);
+        write(`  ${dim(`↳ ${label} ${formatDuration(performance.now() - start)}`)}`)
       }
     },
-  };
+  }
 }
 
-function formatDuration(durationMs: number) {
-  const ms = Math.max(0, durationMs);
-  if (ms < 10) return `${ms.toFixed(1)}ms`;
-  if (ms < 1000) return `${Math.round(ms)}ms`;
-  return `${(ms / 1000).toFixed(ms < 10000 ? 2 : 1)}s`;
+export function formatDuration(durationMs: number) {
+  const ms = Math.max(0, durationMs)
+  if (ms < 10) return `${ms.toFixed(1)}ms`
+  if (ms < 1000) return `${Math.round(ms)}ms`
+  return `${(ms / 1000).toFixed(ms < 10000 ? 2 : 1)}s`
 }

package/reference/overview.md

@@ -1,35 +0,0 @@
-# pnext
-
-pnext is a Preact framework for file-routed applications. It keeps familiar Next-style routing and rendering semantics where they help, and diverges where pnext needs a simpler or smaller model.
-
-It renders on the server by default, passes request data through explicit props, provides strong generated route type safety, and ships client JavaScript only for components that opt into running in the browser.
-
-## Core Model
-
-- Routes live in an `app/` directory.
-- `page.tsx` files define UI routes.
-- `layout.tsx` files export metadata, viewport, and can wrap descendant pages.
-- `route.ts` files define HTTP handlers.
-- `proxy.ts` or `middleware.ts` can run before route matching.
-- `loading.tsx`, `error.tsx`, and `not-found.tsx` define route fallbacks.
-- Pages and layouts are pnext Server Components by default.
-- Server components can be async.
-- Pages without client components emit HTML without pnext client JavaScript.
-- Client Components can be loaded with `dynamic({ load: 'visible' })` and deferred until visible.
-- React compatibility mode supported via `compat.react`.
-- Next compatibility mode supported via `compat.next`.
-- Experimental React Compiler support for React-style Client Components via `compat.reactCompiler`.
-
-## References
-
-- [Config](./config.md)
-- [Routing](./routing.md)
-- [Metadata](./metadata.md)
-- [Navigation](./navigation.md)
-- [Rendering](./rendering.md)
-- [CSS](./css.md)
-- [Environment Variables](./env.md)
-- [Compatibility](./compat.md)
-- [Typegen](./typegen.md)
-- [Dev Server](./dev.md)
-- [Performance](./performance.md)