@solidjs/signals 2.0.0-rc.5 → 2.0.0-rc.7

package/dist/types/store/next/patch.d.ts

@@ -1,91 +0,0 @@
-import type { Owner } from "../../core/types.js";
-import { type StoreNextTarget } from "./target.js";
-export type PatchFn = (next: any, prev: any, force?: boolean) => void;
-interface PatchEntry {
-    fn: PatchFn;
-    owner: Owner | null;
-}
-/**
- * Emit a record's visibility transition. Callers gate on `hasPatches()` and
- * `t.d` cheaply; this function re-checks and walks ancestors (§4b).
- */
-export declare function emitPatch(t: StoreNextTarget, next: any, prev: any): void;
-/** Emission for sites that already stand at the record with both sides in
- * hand and have already handled ancestors (the adoption walk descends —
- * parents were visited first), so no bubbling walk. */
-export declare function emitPatchLocal(t: StoreNextTarget, next: any, prev: any): void;
-export declare function emitPatchOptimistic(t: StoreNextTarget, next: any, prev: any): void;
-/** Row-ops emission at OPTIMISTIC (lane) timing: user drafts on an
- * optimistic family must show structure IN FLIGHT — bypassing the
- * transition stash exactly like emitPatchOptimistic. Two forms:
- * - `ops` given (write site): `nextRows` is the draft's intended visible
- *   list, ops the identity diff against the pre-write optimistic view.
- * - `ops === null` (revert site): RESYNC — the consumer rebuilds retention
- *   by row identity against the live post-revert view, resolved from the
- *   target at drain time (overrides are gone by then, so `pb ?? v` IS the
- *   committed truth). */
-export declare function emitRowOpsOptimistic(t: StoreNextTarget, nextRows: any[] | null, ops: RowOps | null): void;
-/** Test-only accounting probe: the live registration count must return to
- * baseline across register/unbind/demote cycles. @internal */
-export declare function patchCountForTests(): number;
-export declare function hasPatches(): boolean;
-export declare function registerPatch(record: any, fn: PatchFn): () => void;
-/** Dual-driver bind probe (compiler runtime contract): when `record` is a
- * patchable store record, returns its CURRENT raw backing (the driver's
- * initial force-apply reads it directly — no proxy traffic, no tracking);
- * returns undefined otherwise (driver falls back to the effect path).
- * Not patchable: non-records, non-proxies, accessor-bearing records
- * (patches read raw — getters need tracked evaluation), broken chains. */
-export declare function patchableRaw(record: any): Record<PropertyKey, any> | undefined;
-/** Accessor demotion (design §5): a record that acquires an accessor after
- * registration stops being patchable — reads must go through tracked
- * evaluation. Clears patches and repairs the global count; callers re-drive
- * the pulled bodies (demoteToEffects). */
-export declare function demotePatches(t: StoreNextTarget): PatchEntry[] | null;
-/** The demotion re-drive (re-audit blocker 3): each pulled body becomes the
- * SAME dual-driver effect fallback the web runtime would have chosen had the
- * record carried the accessor at bind — a tracked compute pass (next === prev
- * short-circuits every compare into a pure read THROUGH THE PROXY, so getter
- * dependencies track) plus an untracked force-apply at effect timing.
- *
- * Creation is DEFERRED to the effect phase: the trap that discovers the
- * accessor runs mid-draft, and an effect's initial pass must not read
- * through the proxy inside the write window. The record's own transition
- * for that draft is covered by the new effect's initial force-apply.
- *
- * Known edge (documented): a demoted LIST-ROW body re-drives under its
- * registering owner (the list owner), so per-row severing on removal is
- * lost for demoted rows — the effect lives until the LIST disposes. Rows
- * only demote when user code defines an accessor on a row record at
- * runtime. */
-export declare function demoteToEffects(t: StoreNextTarget): void;
-/** Structural ops for one keyed-array transition. `prefix` rows key-matched
- * in place; for each later index i (absolute), `sources[i - prefix]` is the
- * OLD index its row retained from, or -1 for a new row. `removed` holds the
- * dropped old row values (unbind/teardown handles). Aligned value ticks emit
- * NOTHING — ops exist only when structure changed. */
-export interface RowOps {
-    prefix: number;
-    sources: number[];
-    removed: any[];
-}
-/** `ops === null` is the RESYNC form (optimistic revert): the consumer
- * rebuilds retention by row identity against `next` (the live view). */
-export type RowOpsFn = (next: any[], ops: RowOps | null) => void;
-/** Register a structural-ops consumer on a keyed store array (the list
- * container's channel — what `For` consumes through the seam). */
-export declare function registerRowOps(array: any, fn: RowOpsFn): () => void;
-/** Slot patches (shallow arrays) ride the same apply queue: the walk emits
- * per aligned value-replaced slot; application happens at effect phase under
- * the registration owner's lifetime. */
-export declare function emitSlotPatch(t: StoreNextTarget, index: number, next: any, prev: any): void;
-/** Slot patch for shallow arrays: the reconcile walk emits (index, next,
- * prev) for KEY-ALIGNED value-replaced slots (structure rides row ops), and
- * the emission queues through the patch apply queue — effect-phase timing,
- * transition stamping, disposed-owner drop — like every other channel. */
-export declare function registerSlotPatchNext(arr: any, fn: (index: number, next: any, prev: any) => void): () => void;
-/** Row-ops ride the SAME apply queue/timing as record patches: transition-
- * stamped, applied at effect phase, in emission order (structure before the
- * new rows' own patches can exist; retained rows' value patches commute). */
-export declare function emitRowOps(t: StoreNextTarget, next: any[], ops: RowOps): void;
-export {};

package/dist/types-cjs/store/next/patch-hooks.d.cts

@@ -1,41 +0,0 @@
-import type { StoreNextTarget } from "./target.cjs";
-import type { RowOps } from "./patch.cjs";
-/**
- * Patch-channel emission seams (pay-for-use). The store/reconcile/optimistic
- * write paths emit through these installed hook objects instead of importing
- * `patch.js` statically, so the channel tree-shakes out of apps that never
- * register a patch consumer.
- *
- * TWO TIERS, armed at registration (patch.js installs them; it is retained
- * only through its registration exports, which only compiled patch-mode
- * output — via the web runtime's driver module — imports):
- * - VALUE hooks (`patchHooks`): record patches. Armed by `registerPatch` —
- *   present in any bundle with one eligible template under patch mode.
- * - ROW hooks (`rowHooks`): list structure (row ops, slot ticks, the
- *   identity/keyed diff builders in reconcile.js they drag in). Armed by
- *   `registerRowOps`/`registerSlotPatchNext` — the LIST driver's
- *   registrations, so value-only bundles never retain the row machinery.
- *
- * Soundness: every emission site is guarded by the matching `pc` channel
- * (`pc.p` for value, `pc.ro`/`pc.sp` for rows), and a target can only
- * acquire that channel through the corresponding registration — so each
- * hook object is installed by the time any guard passes. Type-only imports
- * from `patch.js` are erased.
- */
-export interface PatchValueHooks {
-    emitPatch(t: StoreNextTarget, next: any, prev: any): void;
-    emitPatchLocal(t: StoreNextTarget, next: any, prev: any): void;
-    emitPatchOptimistic(t: StoreNextTarget, next: any, prev: any): void;
-    hasPatches(): boolean;
-    demoteToEffects(t: StoreNextTarget): void;
-}
-export interface PatchRowHooks {
-    emitRowOps(t: StoreNextTarget, next: any[], ops: RowOps): void;
-    emitSlotPatch(t: StoreNextTarget, index: number, next: any, prev: any): void;
-    emitSetterRowOps(t: StoreNextTarget, prevRows: any[], nextRows: any[]): void;
-    emitRowOpsOptimistic(t: StoreNextTarget, next: any[] | null, ops: RowOps | null): void;
-}
-export declare let patchHooks: PatchValueHooks | null;
-export declare let rowHooks: PatchRowHooks | null;
-export declare function installPatchHooks(hooks: PatchValueHooks): void;
-export declare function installRowHooks(hooks: PatchRowHooks): void;

package/dist/types-cjs/store/next/patch.d.cts

@@ -1,91 +0,0 @@
-import type { Owner } from "../../core/types.cjs";
-import { type StoreNextTarget } from "./target.cjs";
-export type PatchFn = (next: any, prev: any, force?: boolean) => void;
-interface PatchEntry {
-    fn: PatchFn;
-    owner: Owner | null;
-}
-/**
- * Emit a record's visibility transition. Callers gate on `hasPatches()` and
- * `t.d` cheaply; this function re-checks and walks ancestors (§4b).
- */
-export declare function emitPatch(t: StoreNextTarget, next: any, prev: any): void;
-/** Emission for sites that already stand at the record with both sides in
- * hand and have already handled ancestors (the adoption walk descends —
- * parents were visited first), so no bubbling walk. */
-export declare function emitPatchLocal(t: StoreNextTarget, next: any, prev: any): void;
-export declare function emitPatchOptimistic(t: StoreNextTarget, next: any, prev: any): void;
-/** Row-ops emission at OPTIMISTIC (lane) timing: user drafts on an
- * optimistic family must show structure IN FLIGHT — bypassing the
- * transition stash exactly like emitPatchOptimistic. Two forms:
- * - `ops` given (write site): `nextRows` is the draft's intended visible
- *   list, ops the identity diff against the pre-write optimistic view.
- * - `ops === null` (revert site): RESYNC — the consumer rebuilds retention
- *   by row identity against the live post-revert view, resolved from the
- *   target at drain time (overrides are gone by then, so `pb ?? v` IS the
- *   committed truth). */
-export declare function emitRowOpsOptimistic(t: StoreNextTarget, nextRows: any[] | null, ops: RowOps | null): void;
-/** Test-only accounting probe: the live registration count must return to
- * baseline across register/unbind/demote cycles. @internal */
-export declare function patchCountForTests(): number;
-export declare function hasPatches(): boolean;
-export declare function registerPatch(record: any, fn: PatchFn): () => void;
-/** Dual-driver bind probe (compiler runtime contract): when `record` is a
- * patchable store record, returns its CURRENT raw backing (the driver's
- * initial force-apply reads it directly — no proxy traffic, no tracking);
- * returns undefined otherwise (driver falls back to the effect path).
- * Not patchable: non-records, non-proxies, accessor-bearing records
- * (patches read raw — getters need tracked evaluation), broken chains. */
-export declare function patchableRaw(record: any): Record<PropertyKey, any> | undefined;
-/** Accessor demotion (design §5): a record that acquires an accessor after
- * registration stops being patchable — reads must go through tracked
- * evaluation. Clears patches and repairs the global count; callers re-drive
- * the pulled bodies (demoteToEffects). */
-export declare function demotePatches(t: StoreNextTarget): PatchEntry[] | null;
-/** The demotion re-drive (re-audit blocker 3): each pulled body becomes the
- * SAME dual-driver effect fallback the web runtime would have chosen had the
- * record carried the accessor at bind — a tracked compute pass (next === prev
- * short-circuits every compare into a pure read THROUGH THE PROXY, so getter
- * dependencies track) plus an untracked force-apply at effect timing.
- *
- * Creation is DEFERRED to the effect phase: the trap that discovers the
- * accessor runs mid-draft, and an effect's initial pass must not read
- * through the proxy inside the write window. The record's own transition
- * for that draft is covered by the new effect's initial force-apply.
- *
- * Known edge (documented): a demoted LIST-ROW body re-drives under its
- * registering owner (the list owner), so per-row severing on removal is
- * lost for demoted rows — the effect lives until the LIST disposes. Rows
- * only demote when user code defines an accessor on a row record at
- * runtime. */
-export declare function demoteToEffects(t: StoreNextTarget): void;
-/** Structural ops for one keyed-array transition. `prefix` rows key-matched
- * in place; for each later index i (absolute), `sources[i - prefix]` is the
- * OLD index its row retained from, or -1 for a new row. `removed` holds the
- * dropped old row values (unbind/teardown handles). Aligned value ticks emit
- * NOTHING — ops exist only when structure changed. */
-export interface RowOps {
-    prefix: number;
-    sources: number[];
-    removed: any[];
-}
-/** `ops === null` is the RESYNC form (optimistic revert): the consumer
- * rebuilds retention by row identity against `next` (the live view). */
-export type RowOpsFn = (next: any[], ops: RowOps | null) => void;
-/** Register a structural-ops consumer on a keyed store array (the list
- * container's channel — what `For` consumes through the seam). */
-export declare function registerRowOps(array: any, fn: RowOpsFn): () => void;
-/** Slot patches (shallow arrays) ride the same apply queue: the walk emits
- * per aligned value-replaced slot; application happens at effect phase under
- * the registration owner's lifetime. */
-export declare function emitSlotPatch(t: StoreNextTarget, index: number, next: any, prev: any): void;
-/** Slot patch for shallow arrays: the reconcile walk emits (index, next,
- * prev) for KEY-ALIGNED value-replaced slots (structure rides row ops), and
- * the emission queues through the patch apply queue — effect-phase timing,
- * transition stamping, disposed-owner drop — like every other channel. */
-export declare function registerSlotPatchNext(arr: any, fn: (index: number, next: any, prev: any) => void): () => void;
-/** Row-ops ride the SAME apply queue/timing as record patches: transition-
- * stamped, applied at effect phase, in emission order (structure before the
- * new rows' own patches can exist; retained rows' value patches commute). */
-export declare function emitRowOps(t: StoreNextTarget, next: any[], ops: RowOps): void;
-export {};