@playfast/reform-resource 0.0.3

package/README.md

@@ -0,0 +1,52 @@
+# @playfast/reform-resource
+
+Async resources for [Reform](../reform).
+
+Reform renders synchronously, so it builds a scene's whole layer graph with
+`runSync`. A layer whose acquire does async work (open a connection, fetch config,
+`Effect.sleep`) breaks that build — reform now reports it as `AsyncSceneLayer` and
+points you here.
+
+A `Resource` is the sanctioned home for that async work:
+
+- its `live` layer **builds synchronously**, seeding a `pending` value;
+- it **forks the load under the scene scope** (so `acquireRelease` finalizers
+  release when the scene unmounts);
+- when the load settles it flips a reactive store to `ready` (or `failed`), which
+  re-renders any composition that read the resource — exactly like a state/calc.
+
+Unlike `AsyncCalc`, a `Resource` has no reactive inputs and no query driver: it is
+a one-shot, scoped load.
+
+## Usage
+
+```typescript
+import { Resource } from '@playfast/reform-resource'
+import { Effect, Schema as S } from 'effect'
+
+// Define — output schema shapes the ready value; add `error` for a failed arm.
+class Config extends Resource.make('Config', { output: S.Struct({ url: S.String }) }) {}
+
+// Wire — `acquire` may be scoped (acquire/release tied to the scene scope).
+const ConfigLive = Resource.live(
+  Config,
+  Effect.acquireRelease(openConfig, closeConfig),
+)
+
+// Read inside a composition.
+const view = Effect.gen(function* () {
+  const config = yield* Config
+  return config.isReady ? render(config.value) : spinner()
+})
+```
+
+The value is a union discriminated by `isReady`:
+
+```typescript
+type AsyncResource<A, E = never> =
+  | { _tag: 'AsyncResource'; isReady: false; failed: false }       // pending
+  | { _tag: 'AsyncResource'; isReady: true;  value: A }            // ready
+  | { _tag: 'AsyncResource'; isReady: false; failed: true; error: E } // only when E ≠ never
+```
+
+The public API is re-exported from [the package index](./src/index.ts).

package/dist/asyncResource.d.ts

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,9 @@
+// @playfast/reform-resource — async resources for reform.
+//
+// A `Resource` is a layer that builds synchronously (so it's safe in reform's
+// 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

package/dist/index.js.map

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1 @@
+{"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"}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@playfast/reform-resource",
+  "playbook": "./playbook",
+  "version": "0.0.3",
+  "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": [
+    "reform",
+    "effect",
+    "async",
+    "resource",
+    "reactive",
+    "layer"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/playfast/reform.git",
+    "directory": "packages/reform-resource"
+  },
+  "bugs": {
+    "url": "https://github.com/playfast/reform/issues"
+  },
+  "sideEffects": false,
+  "exports": {
+    "./package.json": "./package.json",
+    ".": "./src/index.ts",
+    "./*": "./src/*.ts"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "clean": "rm -rf dist .tsbuildinfo",
+    "check": "tsc --noEmit",
+    "build": "tsc -p tsconfig.build.json",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "coverage": "vitest run --coverage",
+    "lint": "oxlint src",
+    "lint:fix": "oxlint --fix src"
+  },
+  "peerDependencies": {
+    "effect": "*",
+    "@playfast/reform": "*"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}