@playfast/reform-resource 0.0.3 → 0.0.4

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@playfast/reform-resource",
   "playbook": "./playbook",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "type": "module",
   "description": "Async resources for Reform — a layer that builds synchronously, loads in the background, and flips a reactive store from pending to ready/failed. The sanctioned home for async work that would otherwise break reform's synchronous scene build.",
   "keywords": [
@@ -28,7 +28,7 @@
     "./*": "./src/*.ts"
   },
   "files": [
-    "dist",
+    "src",
     "README.md"
   ],
   "scripts": {

package/src/asyncResource.ts

@@ -0,0 +1,80 @@
+import { type Store } from '@playfast/reform'
+
+// The value an `AsyncResource` holds: a tagged union discriminated by `isReady`.
+// A resource builds synchronously as `pending`, its load runs in the background,
+// and the store flips to `ready` (or `failed`, only when an `error` schema is
+// declared) when it settles. Consumed with a plain `if`:
+//
+//   const r = yield* MyResource
+//   if (r.isReady) use(r.value)
+//   else if (r.failed) handle(r.error)   // only present when E is not `never`
+//
+// `_tag` is the constant `'AsyncResource'` (so the value reads well in logs and a
+// `Match.tag` still groups it); `isReady` is the real discriminant.
+
+/** The initial state: the load has not settled yet. */
+export interface AsyncResourcePending {
+  readonly _tag: 'AsyncResource'
+  readonly isReady: false
+  readonly failed: false
+}
+
+/** The load resolved; `value` is the acquired resource. */
+export interface AsyncResourceReady<A> {
+  readonly _tag: 'AsyncResource'
+  readonly isReady: true
+  readonly value: A
+}
+
+/** The load failed with the declared error. Only occurs when `E` is not `never`. */
+export interface AsyncResourceFailed<E> {
+  readonly _tag: 'AsyncResource'
+  readonly isReady: false
+  readonly failed: true
+  readonly error: E
+}
+
+/**
+ * The resource lifecycle, narrowed by the definition: the `Failed` arm exists
+ * only when the resource declares an `error` schema (a non-`never` `E`), so a
+ * resource with no error schema is exactly the two-arm `pending | ready` shape.
+ */
+export type AsyncResource<A, E = never> =
+  | AsyncResourcePending
+  | AsyncResourceReady<A>
+  | ([E] extends [never] ? never : AsyncResourceFailed<E>)
+
+/** The full (un-narrowed) union — held by the live store, narrowed at the read boundary. */
+export type AnyAsyncResource<A, E> = AsyncResourcePending | AsyncResourceReady<A> | AsyncResourceFailed<E>
+
+const pending: AsyncResourcePending = { _tag: 'AsyncResource', isReady: false, failed: false }
+const ready = <A>(value: A): AsyncResourceReady<A> => ({ _tag: 'AsyncResource', isReady: true, value })
+const failed = <E>(error: E): AsyncResourceFailed<E> => ({
+  _tag: 'AsyncResource',
+  isReady: false,
+  failed: true,
+  error,
+})
+
+/** The arm-constructor namespace exposed as `AsyncResource`. */
+export interface AsyncResourceConstructors {
+  readonly pending: AsyncResourcePending
+  readonly ready: <A>(value: A) => AsyncResourceReady<A>
+  readonly failed: <E>(error: E) => AsyncResourceFailed<E>
+}
+
+/**
+ * Constructors for the arms, namespaced under the same name as the type so call
+ * sites read `AsyncResource.ready(v)` / `AsyncResource.failed(e)` — one obvious
+ * home for every arm (mirrors `AsyncData` in reform core).
+ */
+export const AsyncResource: AsyncResourceConstructors = { pending, ready, failed }
+
+/**
+ * Narrow the live store (which holds the full `AnyAsyncResource` union) to the
+ * arms the definition permits (drops `Failed` when `E` is `never`). The single
+ * documented home for that narrowing, so `Resource.live` returns it without an
+ * inline cast — the established `asyncData.narrowStore` pattern.
+ */
+export const narrowStore = <A, E>(store: Store<AnyAsyncResource<A, E>>): Store<AsyncResource<A, E>> =>
+  store as unknown as Store<AsyncResource<A, E>>

package/{dist/index.js → src/index.ts}

@@ -4,6 +4,14 @@
 // synchronous scene build), forks an async load under the scene scope, and flips
 // a reactive store from `pending` to `ready`/`failed` when it settles — the
 // sanctioned home for the async work that otherwise trips `AsyncSceneLayer`.
-export * as Resource from './resource';
-export { AsyncResource, } from './asyncResource';
-//# sourceMappingURL=index.js.map
+
+export * as Resource from './resource'
+export type { ResourceClass, ResourceConfig, ResourceManifest } from './resource'
+export {
+  type AnyAsyncResource,
+  AsyncResource,
+  type AsyncResourceConstructors,
+  type AsyncResourceFailed,
+  type AsyncResourcePending,
+  type AsyncResourceReady,
+} from './asyncResource'

package/src/reform-resource.test.ts

@@ -0,0 +1,79 @@
+import { expect, it } from '@effect/vitest'
+import { Context, Data, Duration, Effect, Layer, Ref, Schema as S } from 'effect'
+import { Resource } from './index'
+
+// A Resource builds synchronously as `pending`, forks its load under the scene
+// scope, and flips a reactive store to `ready`/`failed` when it settles. Scoped
+// acquire/release ties to the scene scope.
+
+const tick = (ms = 30) => Effect.sleep(Duration.millis(ms))
+
+class Boom extends Data.TaggedError('Boom')<{ readonly message: string }> {}
+
+it.live('builds pending then resolves to ready', () => {
+  class Num extends Resource.make('Num', { output: S.Number }) {}
+  const layer = Resource.live(Num, Effect.delay(Effect.succeed(7), Duration.millis(20)))
+
+  return Effect.gen(function* () {
+    const store = yield* Num.store
+    // Synchronous build → the value is available immediately as pending.
+    expect(store.get().isReady).toBe(false)
+    yield* tick(60)
+    const value = store.get()
+    expect(value.isReady).toBe(true)
+    if (value.isReady) expect(value.value).toBe(7)
+  }).pipe(Effect.provide(layer))
+})
+
+it.live('a failing load resolves to the failed arm carrying the error', () => {
+  class Conn extends Resource.make('Conn', { output: S.Number, error: S.instanceOf(Boom) }) {}
+  const layer = Resource.live(Conn, Effect.fail(new Boom({ message: 'nope' })))
+
+  return Effect.gen(function* () {
+    const store = yield* Conn.store
+    yield* tick()
+    const value = store.get()
+    expect(value.isReady).toBe(false)
+    if (!value.isReady && value.failed) expect(value.error.message).toBe('nope')
+  }).pipe(Effect.provide(layer))
+})
+
+it.live('notifies subscribers when it flips to ready', () => {
+  class Num extends Resource.make('Num', { output: S.Number }) {}
+  const layer = Resource.live(Num, Effect.succeed(1))
+
+  return Effect.gen(function* () {
+    const store = yield* Num.store
+    const seen = { count: 0 }
+    const unsubscribe = store.subscribe(() => {
+      seen.count += 1
+    })
+    yield* tick()
+    unsubscribe()
+    expect(store.get().isReady).toBe(true)
+    expect(seen.count).toBeGreaterThan(0)
+  }).pipe(Effect.provide(layer))
+})
+
+it.live('ties acquire/release to the scene scope', () =>
+  Effect.gen(function* () {
+    const released = yield* Ref.make(false)
+    class Conn extends Resource.make('Conn', { output: S.Number }) {}
+    const layer = Resource.live(
+      Conn,
+      Effect.acquireRelease(Effect.succeed(1), () => Ref.set(released, true)),
+    )
+
+    yield* Effect.scoped(
+      Effect.gen(function* () {
+        const context = yield* Layer.build(layer)
+        const store = Context.get(context, Conn.store)
+        yield* tick()
+        expect(store.get().isReady).toBe(true)
+        // Still open while the scene scope is alive.
+        expect(yield* Ref.get(released)).toBe(false)
+      }),
+    )
+    // Scene scope closed → the acquire's finalizer ran.
+    expect(yield* Ref.get(released)).toBe(true)
+  }))

package/src/resource.ts

@@ -0,0 +1,110 @@
+import {
+  type Manifest,
+  makeStore,
+  readTracked,
+  resolveScheduler,
+  type Store,
+  yieldableClass,
+} from '@playfast/reform'
+import { Cause, Context, Effect, Layer, Option, type Schema, Scope } from 'effect'
+import {
+  type AnyAsyncResource,
+  AsyncResource,
+  narrowStore,
+} from './asyncResource'
+
+// `Resource` is the sanctioned home for async work that would otherwise run during
+// reform's synchronous layer build (and trip `AsyncSceneLayer`). Its `live` layer
+// builds synchronously — seeding a `pending` store — then forks the load under the
+// scene scope and flips the store to `ready`/`failed` when it settles. The flip is
+// an ordinary `Store.set`, so a render that read the resource (via `readTracked`)
+// re-runs just like for any state/calc. Unlike `AsyncCalc` it has no reactive
+// inputs and no query driver: a one-shot, scoped load.
+
+export interface ResourceManifest<N extends string, A, E> extends Manifest {
+  readonly kind: 'Resource'
+  readonly name: N
+  readonly output: Schema.Schema<A, any>
+  /** Schema of the failure. Omitted ⇒ the load is infallible and there is no `Failed` arm. */
+  readonly error?: Schema.Schema<E, any>
+}
+
+export interface ResourceClass<out N extends string, in out A, in out E>
+  extends Effect.Effect<AsyncResource<A, E>, never, Store<AsyncResource<A, E>>> {
+  new (): {}
+  readonly manifest: ResourceManifest<N, A, E>
+  readonly store: Context.Tag<Store<AsyncResource<A, E>>, Store<AsyncResource<A, E>>>
+  /** The resource's name. */
+  readonly name: N
+}
+
+export interface ResourceConfig<A, E> {
+  /** Schema of the ready value. */
+  readonly output: Schema.Schema<A, any>
+  /** Schema of the failure. Omitted ⇒ infallible: no `Failed` arm in the value type. */
+  readonly error?: Schema.Schema<E, any>
+}
+
+/**
+ * Define an async resource. `output`/`error` schemas shape the value type, so
+ * `yield* MyResource` is typed to exactly the arms that can occur (no `Failed` arm
+ * without an `error` schema). The load effect itself is supplied by `Resource.live`.
+ */
+export const make = <const N extends string, A, E = never>(
+  name: N,
+  config: ResourceConfig<A, E>,
+): ResourceClass<N, A, E> => {
+  const store = Context.GenericTag<Store<AsyncResource<A, E>>>(`reform/resource/${name}`)
+  const manifest: ResourceManifest<N, A, E> = {
+    kind: 'Resource',
+    name,
+    output: config.output,
+    ...(config.error !== undefined ? { error: config.error } : {}),
+  }
+  const read = Effect.flatMap(store, readTracked)
+  return yieldableClass(read, { manifest, store, name })
+}
+
+/**
+ * Wire the load for a resource. The layer builds synchronously (the store starts
+ * `pending`), then forks `acquire` and flips the store to `ready` on success or
+ * `failed` on a declared failure. `acquire` may be scoped: its `acquireRelease`
+ * finalizers attach to the scene/layer scope (via `Scope.extend`), so an opened
+ * connection stays alive while the resource is mounted and releases on dispose.
+ * A defect (an unexpected throw) is logged and leaves the resource `pending`,
+ * rather than vanishing silently.
+ */
+export const live = <N extends string, A, E, R>(
+  resource: ResourceClass<N, A, E>,
+  acquire: Effect.Effect<A, E, R | Scope.Scope>,
+): Layer.Layer<Store<AsyncResource<A, E>>, never, Exclude<R, Scope.Scope>> =>
+  Layer.scoped(
+    resource.store,
+    Effect.gen(function* () {
+      const scheduler = yield* resolveScheduler
+      const scope = yield* Effect.scope
+      // The store holds the full union; the tag (and `yield* Resource`) see the
+      // definition-narrowed arms. Built `pending` so the sync layer build returns
+      // immediately and never trips `AsyncSceneLayer`.
+      const store = makeStore<AnyAsyncResource<A, E>>(AsyncResource.pending, scheduler)
+      yield* Effect.forkScoped(
+        acquire.pipe(
+          // Finalizers in `acquire` attach to the scene scope, not the load fiber:
+          // a resource opened here lives until the scene unmounts.
+          Scope.extend(scope),
+          Effect.matchCauseEffect({
+            onSuccess: (value) => Effect.sync(() => store.set(AsyncResource.ready(value))),
+            onFailure: (cause) =>
+              Option.match(Cause.failureOption(cause), {
+                onSome: (error) => Effect.sync(() => store.set(AsyncResource.failed(error))),
+                onNone: () =>
+                  Cause.isInterruptedOnly(cause)
+                    ? Effect.void
+                    : Effect.logError(`reform-resource: load for '${resource.name}' failed`, cause),
+              }),
+          }),
+        ),
+      )
+      return narrowStore(store)
+    }),
+  )

package/dist/asyncResource.d.ts

@@ -1,48 +0,0 @@
-import { type Store } from '@playfast/reform';
-/** The initial state: the load has not settled yet. */
-export interface AsyncResourcePending {
-    readonly _tag: 'AsyncResource';
-    readonly isReady: false;
-    readonly failed: false;
-}
-/** The load resolved; `value` is the acquired resource. */
-export interface AsyncResourceReady<A> {
-    readonly _tag: 'AsyncResource';
-    readonly isReady: true;
-    readonly value: A;
-}
-/** The load failed with the declared error. Only occurs when `E` is not `never`. */
-export interface AsyncResourceFailed<E> {
-    readonly _tag: 'AsyncResource';
-    readonly isReady: false;
-    readonly failed: true;
-    readonly error: E;
-}
-/**
- * The resource lifecycle, narrowed by the definition: the `Failed` arm exists
- * only when the resource declares an `error` schema (a non-`never` `E`), so a
- * resource with no error schema is exactly the two-arm `pending | ready` shape.
- */
-export type AsyncResource<A, E = never> = AsyncResourcePending | AsyncResourceReady<A> | ([E] extends [never] ? never : AsyncResourceFailed<E>);
-/** The full (un-narrowed) union — held by the live store, narrowed at the read boundary. */
-export type AnyAsyncResource<A, E> = AsyncResourcePending | AsyncResourceReady<A> | AsyncResourceFailed<E>;
-/** The arm-constructor namespace exposed as `AsyncResource`. */
-export interface AsyncResourceConstructors {
-    readonly pending: AsyncResourcePending;
-    readonly ready: <A>(value: A) => AsyncResourceReady<A>;
-    readonly failed: <E>(error: E) => AsyncResourceFailed<E>;
-}
-/**
- * Constructors for the arms, namespaced under the same name as the type so call
- * sites read `AsyncResource.ready(v)` / `AsyncResource.failed(e)` — one obvious
- * home for every arm (mirrors `AsyncData` in reform core).
- */
-export declare const AsyncResource: AsyncResourceConstructors;
-/**
- * Narrow the live store (which holds the full `AnyAsyncResource` union) to the
- * arms the definition permits (drops `Failed` when `E` is `never`). The single
- * documented home for that narrowing, so `Resource.live` returns it without an
- * inline cast — the established `asyncData.narrowStore` pattern.
- */
-export declare const narrowStore: <A, E>(store: Store<AnyAsyncResource<A, E>>) => Store<AsyncResource<A, E>>;
-//# sourceMappingURL=asyncResource.d.ts.map

package/dist/asyncResource.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"asyncResource.d.ts","sourceRoot":"","sources":["../src/asyncResource.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,kBAAkB,CAAA;AAc7C,uDAAuD;AACvD,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAA;IAC9B,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAA;CACvB;AAED,2DAA2D;AAC3D,MAAM,WAAW,kBAAkB,CAAC,CAAC;IACnC,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAA;IAC9B,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAA;IACtB,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAA;CAClB;AAED,oFAAoF;AACpF,MAAM,WAAW,mBAAmB,CAAC,CAAC;IACpC,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAA;IAC9B,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAA;IACrB,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAA;CAClB;AAED;;;;GAIG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,EAAE,CAAC,GAAG,KAAK,IAClC,oBAAoB,GACpB,kBAAkB,CAAC,CAAC,CAAC,GACrB,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,KAAK,GAAG,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAA;AAE1D,4FAA4F;AAC5F,MAAM,MAAM,gBAAgB,CAAC,CAAC,EAAE,CAAC,IAAI,oBAAoB,GAAG,kBAAkB,CAAC,CAAC,CAAC,GAAG,mBAAmB,CAAC,CAAC,CAAC,CAAA;AAW1G,gEAAgE;AAChE,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,OAAO,EAAE,oBAAoB,CAAA;IACtC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,kBAAkB,CAAC,CAAC,CAAC,CAAA;IACtD,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,mBAAmB,CAAC,CAAC,CAAC,CAAA;CACzD;AAED;;;;GAIG;AACH,eAAO,MAAM,aAAa,EAAE,yBAAsD,CAAA;AAElF;;;;;GAKG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,EAAE,CAAC,EAAE,OAAO,KAAK,CAAC,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAG,KAAK,CAAC,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CAClD,CAAA"}

package/dist/asyncResource.js

@@ -1,23 +0,0 @@
-import {} from '@playfast/reform';
-const pending = { _tag: 'AsyncResource', isReady: false, failed: false };
-const ready = (value) => ({ _tag: 'AsyncResource', isReady: true, value });
-const failed = (error) => ({
-    _tag: 'AsyncResource',
-    isReady: false,
-    failed: true,
-    error,
-});
-/**
- * Constructors for the arms, namespaced under the same name as the type so call
- * sites read `AsyncResource.ready(v)` / `AsyncResource.failed(e)` — one obvious
- * home for every arm (mirrors `AsyncData` in reform core).
- */
-export const AsyncResource = { pending, ready, failed };
-/**
- * Narrow the live store (which holds the full `AnyAsyncResource` union) to the
- * arms the definition permits (drops `Failed` when `E` is `never`). The single
- * documented home for that narrowing, so `Resource.live` returns it without an
- * inline cast — the established `asyncData.narrowStore` pattern.
- */
-export const narrowStore = (store) => store;
-//# sourceMappingURL=asyncResource.js.map

package/dist/asyncResource.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"asyncResource.js","sourceRoot":"","sources":["../src/asyncResource.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,MAAM,kBAAkB,CAAA;AAiD7C,MAAM,OAAO,GAAyB,EAAE,IAAI,EAAE,eAAe,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAA;AAC9F,MAAM,KAAK,GAAG,CAAI,KAAQ,EAAyB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,eAAe,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAA;AACvG,MAAM,MAAM,GAAG,CAAI,KAAQ,EAA0B,EAAE,CAAC,CAAC;IACvD,IAAI,EAAE,eAAe;IACrB,OAAO,EAAE,KAAK;IACd,MAAM,EAAE,IAAI;IACZ,KAAK;CACN,CAAC,CAAA;AASF;;;;GAIG;AACH,MAAM,CAAC,MAAM,aAAa,GAA8B,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,CAAA;AAElF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAO,KAAoC,EAA8B,EAAE,CACpG,KAA8C,CAAA"}

package/dist/index.d.ts

@@ -1,4 +0,0 @@
-export * as Resource from './resource';
-export type { ResourceClass, ResourceConfig, ResourceManifest } from './resource';
-export { type AnyAsyncResource, AsyncResource, type AsyncResourceConstructors, type AsyncResourceFailed, type AsyncResourcePending, type AsyncResourceReady, } from './asyncResource';
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAA;AACtC,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AACjF,OAAO,EACL,KAAK,gBAAgB,EACrB,aAAa,EACb,KAAK,yBAAyB,EAC9B,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,GACxB,MAAM,iBAAiB,CAAA"}

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,0DAA0D;AAC1D,EAAE;AACF,8EAA8E;AAC9E,iFAAiF;AACjF,4EAA4E;AAC5E,6EAA6E;AAE7E,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAA;AAEtC,OAAO,EAEL,aAAa,GAKd,MAAM,iBAAiB,CAAA"}

package/dist/resource.d.ts

@@ -1,40 +0,0 @@
-import { type Manifest, type Store } from '@playfast/reform';
-import { Context, Effect, Layer, type Schema, Scope } from 'effect';
-import { AsyncResource } from './asyncResource';
-export interface ResourceManifest<N extends string, A, E> extends Manifest {
-    readonly kind: 'Resource';
-    readonly name: N;
-    readonly output: Schema.Schema<A, any>;
-    /** Schema of the failure. Omitted ⇒ the load is infallible and there is no `Failed` arm. */
-    readonly error?: Schema.Schema<E, any>;
-}
-export interface ResourceClass<out N extends string, in out A, in out E> extends Effect.Effect<AsyncResource<A, E>, never, Store<AsyncResource<A, E>>> {
-    new (): {};
-    readonly manifest: ResourceManifest<N, A, E>;
-    readonly store: Context.Tag<Store<AsyncResource<A, E>>, Store<AsyncResource<A, E>>>;
-    /** The resource's name. */
-    readonly name: N;
-}
-export interface ResourceConfig<A, E> {
-    /** Schema of the ready value. */
-    readonly output: Schema.Schema<A, any>;
-    /** Schema of the failure. Omitted ⇒ infallible: no `Failed` arm in the value type. */
-    readonly error?: Schema.Schema<E, any>;
-}
-/**
- * Define an async resource. `output`/`error` schemas shape the value type, so
- * `yield* MyResource` is typed to exactly the arms that can occur (no `Failed` arm
- * without an `error` schema). The load effect itself is supplied by `Resource.live`.
- */
-export declare const make: <const N extends string, A, E = never>(name: N, config: ResourceConfig<A, E>) => ResourceClass<N, A, E>;
-/**
- * Wire the load for a resource. The layer builds synchronously (the store starts
- * `pending`), then forks `acquire` and flips the store to `ready` on success or
- * `failed` on a declared failure. `acquire` may be scoped: its `acquireRelease`
- * finalizers attach to the scene/layer scope (via `Scope.extend`), so an opened
- * connection stays alive while the resource is mounted and releases on dispose.
- * A defect (an unexpected throw) is logged and leaves the resource `pending`,
- * rather than vanishing silently.
- */
-export declare const live: <N extends string, A, E, R>(resource: ResourceClass<N, A, E>, acquire: Effect.Effect<A, E, R | Scope.Scope>) => Layer.Layer<Store<AsyncResource<A, E>>, never, Exclude<R, Scope.Scope>>;
-//# sourceMappingURL=resource.d.ts.map

package/dist/resource.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"resource.d.ts","sourceRoot":"","sources":["../src/resource.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,QAAQ,EAIb,KAAK,KAAK,EAEX,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAS,OAAO,EAAE,MAAM,EAAE,KAAK,EAAU,KAAK,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AAClF,OAAO,EAEL,aAAa,EAEd,MAAM,iBAAiB,CAAA;AAUxB,MAAM,WAAW,gBAAgB,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,CAAC,CAAE,SAAQ,QAAQ;IACxE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAA;IAChB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,CAAA;IACtC,4FAA4F;IAC5F,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,CAAA;CACvC;AAED,MAAM,WAAW,aAAa,CAAC,GAAG,CAAC,CAAC,SAAS,MAAM,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,CACrE,SAAQ,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAC7E,QAAQ,EAAE,CAAA;IACV,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;IAC5C,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAA;IACnF,2BAA2B;IAC3B,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAA;CACjB;AAED,MAAM,WAAW,cAAc,CAAC,CAAC,EAAE,CAAC;IAClC,iCAAiC;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,CAAA;IACtC,sFAAsF;IACtF,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,CAAA;CACvC;AAED;;;;GAIG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,CAAC,GAAG,KAAK,EACvD,MAAM,CAAC,EACP,QAAQ,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,KAC3B,aAAa,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAUvB,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAC5C,UAAU,aAAa,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAChC,SAAS,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,KAC5C,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CA8BtE,CAAA"}

package/dist/resource.js

@@ -1,50 +0,0 @@
-import { makeStore, readTracked, resolveScheduler, yieldableClass, } from '@playfast/reform';
-import { Cause, Context, Effect, Layer, Option, Scope } from 'effect';
-import { AsyncResource, narrowStore, } from './asyncResource';
-/**
- * Define an async resource. `output`/`error` schemas shape the value type, so
- * `yield* MyResource` is typed to exactly the arms that can occur (no `Failed` arm
- * without an `error` schema). The load effect itself is supplied by `Resource.live`.
- */
-export const make = (name, config) => {
-    const store = Context.GenericTag(`reform/resource/${name}`);
-    const manifest = {
-        kind: 'Resource',
-        name,
-        output: config.output,
-        ...(config.error !== undefined ? { error: config.error } : {}),
-    };
-    const read = Effect.flatMap(store, readTracked);
-    return yieldableClass(read, { manifest, store, name });
-};
-/**
- * Wire the load for a resource. The layer builds synchronously (the store starts
- * `pending`), then forks `acquire` and flips the store to `ready` on success or
- * `failed` on a declared failure. `acquire` may be scoped: its `acquireRelease`
- * finalizers attach to the scene/layer scope (via `Scope.extend`), so an opened
- * connection stays alive while the resource is mounted and releases on dispose.
- * A defect (an unexpected throw) is logged and leaves the resource `pending`,
- * rather than vanishing silently.
- */
-export const live = (resource, acquire) => Layer.scoped(resource.store, Effect.gen(function* () {
-    const scheduler = yield* resolveScheduler;
-    const scope = yield* Effect.scope;
-    // The store holds the full union; the tag (and `yield* Resource`) see the
-    // definition-narrowed arms. Built `pending` so the sync layer build returns
-    // immediately and never trips `AsyncSceneLayer`.
-    const store = makeStore(AsyncResource.pending, scheduler);
-    yield* Effect.forkScoped(acquire.pipe(
-    // Finalizers in `acquire` attach to the scene scope, not the load fiber:
-    // a resource opened here lives until the scene unmounts.
-    Scope.extend(scope), Effect.matchCauseEffect({
-        onSuccess: (value) => Effect.sync(() => store.set(AsyncResource.ready(value))),
-        onFailure: (cause) => Option.match(Cause.failureOption(cause), {
-            onSome: (error) => Effect.sync(() => store.set(AsyncResource.failed(error))),
-            onNone: () => Cause.isInterruptedOnly(cause)
-                ? Effect.void
-                : Effect.logError(`reform-resource: load for '${resource.name}' failed`, cause),
-        }),
-    })));
-    return narrowStore(store);
-}));
-//# sourceMappingURL=resource.js.map

package/dist/resource.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"resource.js","sourceRoot":"","sources":["../src/resource.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,SAAS,EACT,WAAW,EACX,gBAAgB,EAEhB,cAAc,GACf,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAe,KAAK,EAAE,MAAM,QAAQ,CAAA;AAClF,OAAO,EAEL,aAAa,EACb,WAAW,GACZ,MAAM,iBAAiB,CAAA;AAkCxB;;;;GAIG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,CAClB,IAAO,EACP,MAA4B,EACJ,EAAE;IAC1B,MAAM,KAAK,GAAG,OAAO,CAAC,UAAU,CAA6B,mBAAmB,IAAI,EAAE,CAAC,CAAA;IACvF,MAAM,QAAQ,GAA8B;QAC1C,IAAI,EAAE,UAAU;QAChB,IAAI;QACJ,MAAM,EAAE,MAAM,CAAC,MAAM;QACrB,GAAG,CAAC,MAAM,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC/D,CAAA;IACD,MAAM,IAAI,GAAG,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,WAAW,CAAC,CAAA;IAC/C,OAAO,cAAc,CAAC,IAAI,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAA;AACxD,CAAC,CAAA;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,CAClB,QAAgC,EAChC,OAA6C,EAC4B,EAAE,CAC3E,KAAK,CAAC,MAAM,CACV,QAAQ,CAAC,KAAK,EACd,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,MAAM,SAAS,GAAG,KAAK,CAAC,CAAC,gBAAgB,CAAA;IACzC,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,KAAK,CAAA;IACjC,0EAA0E;IAC1E,4EAA4E;IAC5E,iDAAiD;IACjD,MAAM,KAAK,GAAG,SAAS,CAAyB,aAAa,CAAC,OAAO,EAAE,SAAS,CAAC,CAAA;IACjF,KAAK,CAAC,CAAC,MAAM,CAAC,UAAU,CACtB,OAAO,CAAC,IAAI;IACV,yEAAyE;IACzE,yDAAyD;IACzD,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,EACnB,MAAM,CAAC,gBAAgB,CAAC;QACtB,SAAS,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,aAAa,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;QAC9E,SAAS,EAAE,CAAC,KAAK,EAAE,EAAE,CACnB,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,aAAa,CAAC,KAAK,CAAC,EAAE;YACvC,MAAM,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,aAAa,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;YAC5E,MAAM,EAAE,GAAG,EAAE,CACX,KAAK,CAAC,iBAAiB,CAAC,KAAK,CAAC;gBAC5B,CAAC,CAAC,MAAM,CAAC,IAAI;gBACb,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,8BAA8B,QAAQ,CAAC,IAAI,UAAU,EAAE,KAAK,CAAC;SACpF,CAAC;KACL,CAAC,CACH,CACF,CAAA;IACD,OAAO,WAAW,CAAC,KAAK,CAAC,CAAA;AAC3B,CAAC,CAAC,CACH,CAAA"}