effectweb 0.3.1 → 0.5.0

package/dist/source.js

@@ -0,0 +1,218 @@
+import * as Effect from 'effect/Effect';
+import * as Cause from 'effect/Cause';
+import * as Stream from 'effect/Stream';
+import * as SubscriptionRef from 'effect/SubscriptionRef';
+import * as AtomRegistry from 'effect/unstable/reactivity/AtomRegistry';
+import { protectSnapshot } from './snapshot.js';
+import { reportError, reportSafely } from './errors.js';
+/** Select explicit inputs. Equal results retain their identity and do not notify subscribers. */
+export function mapSource(source, project, equals = Object.is) {
+    let initialized = false;
+    let previousInput;
+    let current;
+    const select = (input) => {
+        if (initialized && Object.is(previousInput, input))
+            return current;
+        const next = protectSnapshot(project(input));
+        if (!initialized || !equals(current, next))
+            current = next;
+        previousInput = input;
+        initialized = true;
+        return current;
+    };
+    const model = () => select(source.model());
+    return {
+        model,
+        subscribe(listener) {
+            let previous = model();
+            return source.subscribe((value) => {
+                const next = select(value);
+                if (Object.is(previous, next))
+                    return;
+                previous = next;
+                listener(next);
+            });
+        },
+    };
+}
+function publication(initial) {
+    let current = protectSnapshot(initial);
+    let disposed = false;
+    const listeners = new Set();
+    const source = {
+        model: () => current,
+        subscribe: (listener) => {
+            if (disposed)
+                return () => { };
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+    };
+    return {
+        source,
+        publish(value) {
+            if (disposed || Object.is(current, value))
+                return;
+            current = protectSnapshot(value);
+            const next = current;
+            // oxlint-disable-next-line unicorn/no-useless-spread -- Reentrant subscriptions must not join the publication in progress.
+            for (const listener of [...listeners]) {
+                if (disposed || current !== next)
+                    break;
+                if (listeners.has(listener)) {
+                    try {
+                        listener(next);
+                    }
+                    catch (error) {
+                        reportSafely(reportError, error);
+                    }
+                }
+            }
+        },
+        dispose() {
+            disposed = true;
+            listeners.clear();
+        },
+    };
+}
+/** Observe a snapshot stream in the current Effect scope. Handle typed stream errors as values upstream. */
+export const fromStream = (stream, initial) => Effect.gen(function* () {
+    const state = yield* Effect.acquireRelease(Effect.sync(() => publication(initial)), (state) => Effect.sync(() => state.dispose()));
+    yield* Stream.runForEach(stream, (value) => Effect.sync(() => state.publish(value))).pipe(Effect.catchCause((cause) => Effect.sync(() => {
+        if (!Cause.hasInterruptsOnly(cause))
+            reportSafely(reportError, cause);
+    })), Effect.forkScoped({ startImmediately: true }));
+    return state.source;
+});
+/** Observe the existing ref; closing the observation leaves the ref and its other users alive. */
+export const fromSubscriptionRef = (ref) => Effect.gen(function* () {
+    const initial = yield* SubscriptionRef.get(ref);
+    return yield* fromStream(SubscriptionRef.changes(ref), initial);
+});
+export function fromAtom(atom, provided) {
+    return Effect.gen(function* () {
+        const registry = provided ?? (yield* AtomRegistry.AtomRegistry);
+        const state = yield* Effect.acquireRelease(Effect.sync(() => publication(registry.get(atom))), (state) => Effect.sync(() => state.dispose()));
+        yield* Effect.acquireRelease(Effect.sync(() => registry.subscribe(atom, (value) => state.publish(value), { immediate: true })), (unsubscribe) => Effect.sync(unsubscribe));
+        return state.source;
+    });
+}
+/** A batched publication boundary for independently owned sessions with explicit invalidation. */
+export function projectionSource(options) {
+    const listeners = new Set();
+    const subscriptions = new Set();
+    let published;
+    let started = false;
+    let disposed = false;
+    let queued = false;
+    let revision = 0;
+    const changed = () => {
+        if (disposed)
+            return;
+        revision++;
+        options.invalidate?.();
+        if (!started || queued)
+            return;
+        queued = true;
+        queueMicrotask(flush);
+    };
+    function flush() {
+        queued = false;
+        if (disposed)
+            return;
+        options.refresh?.();
+        if (disposed)
+            return;
+        const version = revision;
+        const value = options.project();
+        const next = protectSnapshot(options.reconcile ? options.reconcile(published, value) : value);
+        if (disposed || version !== revision)
+            return;
+        if (next !== published) {
+            published = next;
+            // oxlint-disable-next-line unicorn/no-useless-spread -- Reentrant subscriptions start with the next publication.
+            for (const listener of [...listeners]) {
+                if (disposed)
+                    break;
+                if (listeners.has(listener)) {
+                    try {
+                        listener(next);
+                    }
+                    catch (error) {
+                        reportSafely(reportError, error);
+                    }
+                }
+            }
+        }
+        if (!disposed)
+            options.afterPublish?.();
+    }
+    return {
+        get disposed() {
+            return disposed;
+        },
+        changed,
+        watch(source) {
+            if (disposed)
+                return () => { };
+            const unsubscribe = source.subscribe(changed);
+            let active = true;
+            const stop = () => {
+                if (!active)
+                    return;
+                active = false;
+                subscriptions.delete(stop);
+                unsubscribe();
+            };
+            if (disposed)
+                stop();
+            else
+                subscriptions.add(stop);
+            return stop;
+        },
+        start() {
+            if (disposed || started)
+                return;
+            options.refresh?.();
+            if (disposed)
+                return;
+            const version = revision;
+            published = protectSnapshot(options.project());
+            started = true;
+            if (version !== revision)
+                changed();
+        },
+        model() {
+            if (!started)
+                throw new Error('Start projection publication before reading its model');
+            return published;
+        },
+        subscribe(listener) {
+            if (disposed)
+                return () => { };
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            listeners.clear();
+            const errors = [];
+            for (const stop of [...subscriptions].reverse()) {
+                try {
+                    stop();
+                }
+                catch (error) {
+                    errors.push(error);
+                }
+            }
+            if (errors.length)
+                throw new AggregateError(errors, 'Projection subscription cleanup failed');
+        },
+    };
+}

package/dist/task.d.ts

@@ -1,5 +1,5 @@
 import type { Snapshot } from './snapshot.js';
-import { Effect } from 'effect';
+import * as Effect from 'effect/Effect';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
 import type { View } from './dom.js';
 import { type Send, type TaskPolicy } from './program.js';

package/dist/task.js

@@ -1,5 +1,7 @@
 import { commandSlot } from './program.js';
-import { Cause, Effect, Option } from 'effect';
+import * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
 import { programView } from './component.js';
 import { effectCommand, } from './program.js';

package/dist/tasks.d.ts

@@ -1,13 +1,14 @@
 import type { Snapshot } from './snapshot.js';
-import type { ModelOwner, TaskPolicy } from './owner.js';
-import { Effect } from 'effect';
+import type { TaskPolicy } from './owner.js';
+import * as Effect from 'effect/Effect';
+import type * as Scope from 'effect/Scope';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
 import type { View } from './dom.js';
 import { type CommandSlot, type Send, type RunningProgram } from './program.js';
 import { type UiRuntime } from './runtime.js';
 export interface TaskDefinition<Model, Input, A, E, R = never> {
     readonly policy: Exclude<TaskPolicy, 'parallel'>;
-    readonly run: (model: Snapshot<Model>, input: Input) => Effect.Effect<A, E, R>;
+    readonly run: (model: Snapshot<Model>, input: Input) => Effect.Effect<A, E, R | Scope.Scope>;
     /** Domain identity, compared after fields or props change. Resets this slot only. */
     readonly identity?: (model: Snapshot<Model>) => unknown;
 }
@@ -55,19 +56,21 @@ interface ControllerTask<R> {
     /** Actions sharing a slot share cancellation and concurrency rules. Defaults to a fresh operation identity for this definition. */
     readonly slot?: CommandSlot;
 }
-export declare function defineTasks<Owner extends Pick<ModelOwner<object>, 'run'>, T extends Record<string, ControllerTask<Effect.Services<Parameters<Owner['run']>[1]>>>>(owner: Owner, definitions: T): {
+export declare function defineTasks<Owner extends {
+    readonly run: (slot: CommandSlot, effect: Effect.Effect<never>, policy: TaskPolicy) => void;
+}, T extends Record<string, ControllerTask<Effect.Services<Parameters<Owner['run']>[1]>>>>(owner: Owner, definitions: T): {
     readonly [K in keyof T]: (...args: Parameters<T[K]['run']>) => void;
 };
 export declare function defineTasks<Props, State extends object, R>(definition: Init<Props, State> & {
     runtime: UiRuntime<R>;
 }): ReturnType<typeof taskBuilder<Props, State, R>>;
 export declare function defineTasks<Props, State extends object>(definition: Init<Props, State>): ReturnType<typeof taskBuilder<Props, State, never>>;
-declare function taskBuilder<Props, State extends object, R>(definition: Init<Props, State>, runtime: UiRuntime<R>): {
+declare function taskBuilder<Props, State extends object, R>(definition: Init<Props, State>, runtime: UiRuntime<R> | undefined): {
     tasks<T extends Definitions<State & {
         readonly props: Props;
     }, R>>(definitions: T): {
         slot: (name: keyof T) => CommandSlot;
-        create: (props: Props | Snapshot<Props>) => RunningProgram<TasksModel<Props, State, T>, TasksMessage<State, T>>;
+        create: (props: Props | Snapshot<Props>, ownerRuntime?: UiRuntime<never>) => RunningProgram<TasksModel<Props, State, T>, TasksMessage<State, T>>;
         receive: (source: RunningProgram<TasksModel<Props, State, T>, TasksMessage<State, T>>, props: Props | Snapshot<Props>) => void;
         controls: (send: Send<TasksMessage<State, T>>) => {
             run: <K extends keyof T>(task: K, ...input: InputArguments<T[K]>) => void;

package/dist/tasks.js

@@ -1,4 +1,5 @@
-import { Effect, Option } from 'effect';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
 import { programView } from './component.js';
 import { commandSlot, effectCommand, program, } from './program.js';
@@ -13,7 +14,7 @@ export function defineTasks(definition, definitions) {
         }
         return actions;
     }
-    return taskBuilder(definition, definition.runtime ?? defaultUiRuntime);
+    return taskBuilder(definition, definition.runtime);
 }
 function stopWaiting(result) {
     if (!result.waiting)
@@ -46,9 +47,11 @@ function taskBuilder(definition, runtime) {
                 return { model, cancel };
             };
             const owners = new WeakMap();
-            const create = (props) => {
+            const create = (props, ownerRuntime = defaultUiRuntime) => {
+                const execution = runtime ?? ownerRuntime;
                 const source = program({
                     initial: init(props),
+                    runtime: ownerRuntime,
                     ...(definition.name ? { name: definition.name } : {}),
                     update: (snapshot, message) => {
                         // Internal immutable reconstruction retains the declared domain types.
@@ -72,7 +75,7 @@ function taskBuilder(definition, runtime) {
                                     model: withResult(model, message.task, AsyncResult.waiting(previous)),
                                     commands: [
                                         {
-                                            ...effectCommand(slot(message.task), () => runtime.provide(task.run(snapshot, message.input)), {
+                                            ...effectCommand(slot(message.task), () => execution.provideScoped(task.run(snapshot, message.input)), {
                                                 policy: task.policy,
                                                 onSuccess: (value) => ({
                                                     type: 'Settled',

package/dist/testing.d.ts

@@ -1,12 +1,13 @@
-import { Effect } from 'effect';
+import * as Effect from 'effect/Effect';
 import type { CommandSlot, Program, RunningProgram } from './program.js';
 import { type UiRuntime } from './runtime.js';
 /** Program inspection and controlled Effect execution with application-owned services. */
 export interface ProgramDriver<M, Msg, R = never> extends Program<M, Msg> {
+    readonly close: RunningProgram<M, Msg>['close'];
     readonly activeSlots: RunningProgram<M, Msg>['activeSlots'];
-    readonly awaitSlot: (slot: CommandSlot) => Promise<void>;
-    readonly awaitIdle: () => Promise<void>;
-    readonly run: <A, E>(effect: Effect.Effect<A, E, R>) => Promise<A>;
+    readonly awaitSlot: (slot: CommandSlot) => Effect.Effect<void>;
+    readonly awaitIdle: () => Effect.Effect<void>;
+    readonly run: <A, E>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E>;
 }
 export declare function programDriver<M, Msg>(source: RunningProgram<M, Msg>): ProgramDriver<M, Msg>;
 export declare function programDriver<M, Msg, R>(source: RunningProgram<M, Msg>, runtime: UiRuntime<R>): ProgramDriver<M, Msg, R>;

package/dist/testing.js

@@ -1,4 +1,5 @@
-import { Cause, Effect } from 'effect';
+import * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
 import { defaultUiRuntime } from './runtime.js';
 export function programDriver(source, runtime) {
     return makeDriver(source, runtime ?? defaultUiRuntime);
@@ -9,10 +10,11 @@ function makeDriver(source, runtime) {
         send: source.send,
         subscribe: source.subscribe,
         dispose: source.dispose,
+        close: source.close,
         activeSlots: source.activeSlots,
         awaitSlot: (slot) => source.awaitIdle(slot),
         awaitIdle: () => source.awaitIdle(),
-        run: (effect) => Effect.runPromise(runtime.provide(effect)),
+        run: runtime.provide,
     };
 }
 /** A reusable controlled request, with cancellation visible to tests. No renderer or private messages. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effectweb",
-  "version": "0.3.1",
+  "version": "0.5.0",
   "description": "Immutable Effect models and compiled JSX with direct DOM rendering",
   "homepage": "https://github.com/DerpyCrabs/EffectWeb",
   "bugs": {
@@ -14,8 +14,7 @@
   },
   "files": [
     "dist",
-    "LICENSE",
-    "README.md"
+    "LICENSE"
   ],
   "type": "module",
   "sideEffects": false,
@@ -96,6 +95,14 @@
       "types": "./dist/runtime.d.ts",
       "import": "./dist/runtime.js"
     },
+    "./source": {
+      "types": "./dist/source.d.ts",
+      "import": "./dist/source.js"
+    },
+    "./render": {
+      "types": "./dist/render.d.ts",
+      "import": "./dist/render.js"
+    },
     "./form": {
       "types": "./dist/form.d.ts",
       "import": "./dist/form.js"

package/README.md

@@ -1,101 +0,0 @@
-# effectweb
-
-Immutable Effect models and JSX compiled to direct DOM updates, without signals, proxies, or virtual DOM.
-
-Use with `@effectweb/compiler/vite` and Effect `4.0.0-rc.112`. The package includes programs, named tasks, async presentation, query caching, DOM lifetimes, and `effectweb/testing` helpers.
-
-See [setup and example](https://github.com/DerpyCrabs/EffectWeb#vite-setup).
-
-Runtime and compiler versions advance together. Client-side only. Persistence and multi-tab coordination belong to the application.
-
-## Query identity and account ownership
-
-A query definition has its own identity. Within one cache, all request arguments form its key automatically:
-
-```ts
-const page = query({
-  name: 'message-page',
-  load: (args: { accountId: string; threadId: string; cursor?: string }) =>
-    api.messages(args.accountId, args.threadId, args.cursor),
-});
-```
-
-Request arguments use the same canonical encoding for cache lookup, prefetch, writes, invalidation, and `queryResource.select`. Object property order is ignored; array order matters. Strings, finite numbers, booleans, `null`, and explicit `undefined` are supported recursively in dense arrays and plain objects. Missing properties differ from properties containing `undefined`, and `0` differs from `-0`. Functions, symbols, bigint, nonfinite numbers, cycles, class instances, accessors, nonenumerable properties, sparse arrays, and arrays with extra properties throw `TypeError`. Repeated references to the same plain object are supported. Published argument objects are frozen and are not cloned.
-
-Pass every load-relevant value as an argument, including account, filters, pagination, locale, and permissions when they affect the result. Custom `key` projections are rejected. Provide service instances through the Effect environment instead of query arguments. Separate query definitions do not share entries even if their names and arguments match. `select(undefined)` disables selection; an explicit `undefined` inside an argument object remains part of its identity. A query without arguments uses `true` for selection and prefetch.
-
-Give authenticated data an account lifetime:
-
-```ts
-const account = modelOwner({ accountId }, { runtime });
-const cache = account.own(makeQueryCache(runtime));
-const messages = observeQuery(account, cache, page, (result) => {
-  // Publish the immutable result into application state.
-});
-messages.select({ accountId, threadId });
-
-// Sign out or switch account: dispose this lifetime, then create the next one.
-account.dispose();
-```
-
-Independent caches isolate account data even when services derive authentication from their environment. If an application deliberately reuses a cache across accounts, include account identity in every authenticated query key and call `cache.resetResources()` at the boundary before selecting the new account. Reset interrupts old resources and returns existing query observers to their initial state; select again to enter the new generation. Disposing only a query observer releases its subscription; it does not erase shared cached values. Own shared caches at the account or application scope, not in individual views.
-
-Use `cache.setQueryData(query, args, value)` to seed or replace a cached success, and `cache.updateQueryData(query, args, update)` to change an existing success. The updater receives readonly data; returning `undefined` skips the write. Both publish to current observers and supersede pending loads for those arguments. Use `setQueryData` to store a successful `undefined` value. Query definitions and cache registries are opaque; use the public cache and observation methods.
-
-## Write concurrency
-
-`modelOwner.run(slot, effect, policy)` and `defineTasks(owner, definitions)` support these policies:
-
-| Policy          | Behavior for an occupied slot                                           |
-| --------------- | ----------------------------------------------------------------------- |
-| `drop`          | Ignore the new request.                                                 |
-| `replace`       | Cancel active work and discard pending requests; start the new request. |
-| `parallel`      | Start the new request alongside active work.                            |
-| `queue`         | Append the request; run it after earlier work finishes.                 |
-| `latest-queued` | Keep active work; replace all pending requests with the newest request. |
-
-Every command requires an explicit `policy`. Create stable operation identities with `commandSlot('save')`; equal diagnostic names do not share a slot. Component `defineTasks(...).tasks(...)` and `taskComponent` support all except `parallel`, since their single result slot represents serial work. Command mapping and runtime service provisioning preserve the policy. Actions sharing a slot share concurrency and cancellation. A queued request waits for every active request in that slot if policies are mixed; keep a consistent policy per slot for predictable write behavior.
-
-Use `queue` when each accepted operation matters, such as appending messages. Use `latest-queued` when saving complete document snapshots and only the newest pending snapshot matters:
-
-```ts
-const writes = defineTasks(owner, {
-  save: { policy: 'latest-queued', run: (document: Snapshot<Document>) => storage.save(document) },
-});
-
-writes.save(owner.read().document);
-```
-
-Component tasks capture the model snapshot and input when `Run` is submitted, including requests that wait in a queue. Editing fields afterward does not replace that captured model. Controller tasks retain their supplied arguments; their factories execute when work starts. Pass `owner.read()` data as arguments to capture submission state, or read inside the Effect when execution-time state is intended. Effects and inputs are retained, not deep-cloned; keep supplied data immutable. Dropped and coalesced pending factories are never invoked.
-
-Queue progress continues after successes, typed failures, or defects. Component results remain `waiting` while more work is pending, publish each settlement, and retain the latest successful value if a later write fails. Action failures use the owner's error reporter. `cancel`, component reset or identity change, and disposal discard pending requests and interrupt active work; stale command completions cannot publish afterward. `awaitIdle` includes pending work. Cancellation cannot undo an external write that already completed. Transactions admit their whole command batch before starting Effects, so replacements and cancellation can remove superseded work without executing it.
-
-## Lazy views and portals
-
-`lazyView(() => fromPromise(() => import('./Reader').then((module) => module.Reader)))` loads a view when mounted. It accepts typed `pending` and `failure` views and a `runtime` when the loader requires services. Each unresolved placement owns its load; unmounting interrupts it. Successful definitions are cached for future mounts. Render a lazy view through `ViewBinding` with its current model and sender.
-
-`<Portal mount={model.dialogHost}>...</Portal>` renders into a supplied HTML or SVG element. Omitting `mount` uses the document body. Portal content retains its owner, events, and cleanup; changing between HTML and SVG targets rebuilds content in the correct namespace.
-
-## Inspect source dependencies
-
-Mount a development panel before mounting the application so it sees initial evaluations:
-
-```ts
-import { mountBindingInspector } from 'effectweb/diagnostics';
-
-const removeInspector = mountBindingInspector(document.querySelector<HTMLElement>('#inspector')!);
-// Mount the application here. On teardown or HMR:
-// removeInspector();
-```
-
-The live, filterable table shows original file/line/column, source expressions, inferred snapshot dependencies, the latest changed dependency names, and derive/binding evaluation counts. It uses development compiler metadata; production builds emit none. Counts include initial evaluations, aggregate instances of the same source expression, and measure evaluations rather than actual DOM writes. Change reasons use reference/value equality, without retaining previous or next values.
-
-For custom tooling, `inspectBindings({ limit: 200 })` returns `entries()`, `subscribe(listener)`, `clear()`, and `dispose()`. Entries are immutable metadata, newest first, with at most 1000 source records. Least recently updated sources are evicted and start fresh if seen again. `dispose()` unsubscribes and clears retained metadata. `mountBindingInspector(element, inspector)` can share an inspector; removing that panel leaves the supplied inspector running. Low-level `observeBindings` remains available.
-
-The inspector covers instrumented derivations and text/attribute bindings; it is not a snapshot recorder, time-travel debugger, or complete profile of branch/list reconciliation. Source labels describe the compiler's inferred dependencies, not a proof that an opaque helper has no hidden state.
-
-## Immutable inputs and outputs
-
-Published `Snapshot<T>` values are recursively readonly, including nested arrays/tuples and async success data. View/slot composition, component inputs, owner patches, and task field updates accept readonly branches without casts. Query cache reads, subscriptions, and prefetch publish the same readonly data. Plain objects and arrays are frozen before publication in every build; snapshot protection cannot be disabled.
-
-Functions, Effects, DOM nodes, and explicitly marked service classes retain their own API. See the [authoring guide](https://github.com/DerpyCrabs/EffectWeb/blob/main/docs/authoring.md) for migration examples, `SnapshotOpaque`, state ownership, form composition, and reconciling async loads with live updates.

package/dist/intrinsic.d.ts

@@ -1,2 +0,0 @@
-/** Preserve receiver identity and JavaScript call/optional-chain semantics. */
-export declare function intrinsic<T>(receiver: T, path: readonly (string | null)[], method: string): T;

package/dist/intrinsic.js

@@ -1,120 +0,0 @@
-import { compiledSlots } from './slotIdentity.js';
-// Compiler implementation detail. An untyped receiver's method name is not
-// evidence that it is a standard data operation. Validate its descriptor before
-// invoking it, without running a user getter in the process.
-const prototypes = [
-    Array.prototype,
-    String.prototype,
-    Number.prototype,
-    Boolean.prototype,
-    BigInt.prototype,
-    Function.prototype,
-    Date.prototype,
-    RegExp.prototype,
-    Map.prototype,
-    Set.prototype,
-    URL.prototype,
-    URLSearchParams.prototype,
-    Blob.prototype,
-    File.prototype,
-    Object.getPrototypeOf(Uint8Array.prototype),
-    Intl.DateTimeFormat.prototype,
-    Intl.NumberFormat.prototype,
-    Intl.Collator.prototype,
-    Intl.RelativeTimeFormat.prototype,
-    Intl.PluralRules.prototype,
-    Intl.ListFormat.prototype,
-    Intl.Segmenter.prototype,
-];
-const operations = new Map();
-for (const prototype of prototypes) {
-    for (const [name, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(prototype))) {
-        if (name === 'constructor')
-            continue;
-        const entries = operations.get(name) ?? [];
-        entries.push(descriptor);
-        operations.set(name, entries);
-    }
-}
-/** Preserve receiver identity and JavaScript call/optional-chain semantics. */
-export function intrinsic(receiver, path, method) {
-    checkPath(receiver, path, 0, method);
-    return receiver;
-}
-function checkPath(target, path, index, method) {
-    if (target === null || target === undefined)
-        return;
-    if (index === path.length) {
-        checkIntrinsic(target, method);
-        return;
-    }
-    const field = path[index];
-    if (field === null) {
-        if (Array.isArray(target)) {
-            for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(target))) {
-                if (!/^(0|[1-9]\d*)$/u.test(key))
-                    continue;
-                if (!Object.hasOwn(descriptor, 'value'))
-                    throw new Error('EffectWeb render data cannot use an array accessor. Pass immutable values.');
-                checkPath(descriptor.value, path, index + 1, method);
-            }
-        }
-        else if (target instanceof Map) {
-            for (const value of Map.prototype.values.call(target))
-                checkPath(value, path, index + 1, method);
-        }
-        else if (target instanceof Set) {
-            for (const value of Set.prototype.values.call(target))
-                checkPath(value, path, index + 1, method);
-        }
-        return;
-    }
-    let object = Object(target);
-    while (object) {
-        const descriptor = Object.getOwnPropertyDescriptor(object, field);
-        if (descriptor) {
-            if (Object.hasOwn(descriptor, 'value')) {
-                checkPath(descriptor.value, path, index + 1, method);
-            }
-            else if (descriptor.get &&
-                operations.get(field)?.some((operation) => operation.get === descriptor.get)) {
-                // Native getters are checked by identity before execution. File/Blob
-                // metadata and collection sizes expose data through readonly accessors.
-                checkPath(descriptor.get.call(target), path, index + 1, method);
-            }
-            else {
-                throw new Error('EffectWeb render data cannot use an accessor to supply a standard data operation. Pass immutable data or a checked helper.');
-            }
-            return;
-        }
-        object = Object.getPrototypeOf(object);
-    }
-}
-function checkIntrinsic(receiver, method) {
-    if (receiver === null || receiver === undefined)
-        return;
-    if (method === '@slot') {
-        if (typeof receiver !== 'function' || !compiledSlots.has(receiver))
-            throw new Error('EffectWeb render callbacks must be compiled slots. Declare markup with slot(), or use a checked helper with an explicit purity contract.');
-        return;
-    }
-    let object = Object(receiver);
-    while (object) {
-        const descriptor = Object.getOwnPropertyDescriptor(object, method);
-        if (descriptor) {
-            const known = operations
-                .get(method)
-                ?.some((operation) => Object.hasOwn(descriptor, 'value')
-                ? typeof descriptor.value === 'function' && descriptor.value === operation.value
-                : descriptor.get !== undefined &&
-                    descriptor.get === operation.get &&
-                    descriptor.set === undefined);
-            if (!known)
-                throw new Error(`EffectWeb cannot prove .${method} is a standard data operation. Use a checked local helper or an imported helper with a purity contract.`);
-            return;
-        }
-        object = Object.getPrototypeOf(object);
-    }
-    // The original member call retains its own missing/optional-method behavior.
-    return;
-}

package/dist/slotIdentity.d.ts

@@ -1 +0,0 @@
-export declare const compiledSlots: WeakSet<object>;

package/dist/slotIdentity.js

@@ -1,2 +0,0 @@
-// Shared only by compiler runtime helpers; user functions cannot acquire this proof.
-export const compiledSlots = new WeakSet();