@warp-drive/core 5.9.0-beta.1 → 5.9.0-beta.3

package/dist/unpkg/prod/index.js

@@ -1,3 +1,3 @@
-import { D as setIdentifierUpdateMethod, E as setIdentifierResetMethod, I as storeFor, O as setKeyInfoForResource, P as recordIdentifierFor, T as setIdentifierGenerationMethod, _ as Store, g as CacheHandler, n as RequestManager, r as Fetch, t as useRecommendedStore, w as setIdentifierForgetMethod } from "./src-Dzz-j6pp.js";
+import { D as setIdentifierUpdateMethod, E as setIdentifierResetMethod, I as storeFor, O as setKeyInfoForResource, P as recordIdentifierFor, T as setIdentifierGenerationMethod, _ as Store, g as CacheHandler, n as RequestManager, r as Fetch, t as useRecommendedStore, w as setIdentifierForgetMethod } from "./src-C0wuASrN.js";
 
 export { CacheHandler, Fetch, RequestManager, Store, recordIdentifierFor as cacheKeyFor, recordIdentifierFor, setIdentifierForgetMethod, setIdentifierGenerationMethod, setIdentifierResetMethod, setIdentifierUpdateMethod, setKeyInfoForResource, storeFor, useRecommendedStore };

package/dist/unpkg/prod/reactive/-private.js

@@ -1,3 +1,3 @@
-import { r as Context } from "../-private-Z9i0icpE.js";
+import { r as Context } from "../-private-8gd8hbwm.js";
 
 export { Context };

package/dist/unpkg/prod/reactive.js

@@ -1,5 +1,5 @@
-import { i as getRequestState, r as createRequestSubscription, t as getPromiseState } from "./-private-TNaS5Piv.js";
-import { t as Checkout } from "./-private-Z9i0icpE.js";
-import { a as fromIdentity, c as instantiateRecord, d as commit, i as SchemaService, l as teardownRecord, o as registerDerivations, s as withDefaults, u as checkout } from "./src-Dzz-j6pp.js";
+import { d as getRequestState, t as getPromiseState, u as createRequestSubscription } from "./-private-ggVX_Iob.js";
+import { t as Checkout } from "./-private-8gd8hbwm.js";
+import { a as fromIdentity, c as instantiateRecord, d as commit, i as SchemaService, l as teardownRecord, o as registerDerivations, s as withDefaults, u as checkout } from "./src-C0wuASrN.js";
 
 export { Checkout, SchemaService, checkout, commit, createRequestSubscription, fromIdentity, getPromiseState, getRequestState, instantiateRecord, registerDerivations, teardownRecord, withDefaults };

package/dist/unpkg/prod/{request-BcJNzSgv.js → request-BoeppjDj.js}

@@ -1,4 +1,4 @@
-import { n as getOrSetUniversal, t as getOrSetGlobal } from "./-private-BK71-uXR.js";
+import { n as getOrSetUniversal, t as getOrSetGlobal } from "./-private-B6aLbrgV.js";
 import { IS_FUTURE, STRUCTURED } from "./types/request.js";
 
 //#region src/request/-private/context.ts
@@ -477,4 +477,4 @@ const withBrand = withResponseType;
 
 //#endregion
 export { upgradePromise as a, executeNextHandler as c, getRequestResult as d, setPromiseResult as f, createDeferred as i, clearRequestResult as l, withReactiveResponse as n, DOMError as o, cloneResponseProperties as p, withResponseType as r, IS_CACHE_HANDLER as s, withBrand as t, getPromiseResult as u };
-//# sourceMappingURL=request-BcJNzSgv.js.map
+//# sourceMappingURL=request-BoeppjDj.js.map

package/dist/unpkg/prod/request-BoeppjDj.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-BoeppjDj.js","names":["SkipCache","deepFreeze","createDeferred","upgradeHeaders","headers","clone","Headers","toJSON","Array","from","cloneResponseProperties","response","ok","redirected","status","statusText","type","url","ContextOwner","hasSetStream","hasSetResponse","hasSubscribers","stream","nextCalled","constructor","request","god","isRoot","requestId","id","controller","promise","sizeHint","signal","addEventListener","abort","reason","enhancedRequest","Object","assign","then","hasRequestedStream","getResponse","getStream","hint","get","parseInt","setStream","Promise","resolve","resolveStream","setResponse","Response","responseData","Context","owner","isCacheHandler","___owner","_isCacheHandler","_finalized","setIdentifier","identifier","_finalize","getOrSetUniversal","PromiseCache","WeakMap","RequestMap","Map","setRequestResult","requestId","result","set","clearRequestResult","delete","getRequestResult","get","setPromiseResult","promise","getPromiseResult","getOrSetGlobal","STRUCTURED","Context","ContextOwner","assertValidRequest","createFuture","isFuture","setRequestResult","IS_CACHE_HANDLER","Symbol","DOMError","DOMException","Error","curryFuture","owner","inbound","outbound","setStream","getStream","then","doc","document","request","response","content","resolve","error","isDoc","god","stream","e","Object","assign","message","getResponse","reject","promise","ensureDoc","isError","enhanceReason","reason","name","handleOutcome","controller","signal","aborted","isCacheHandler","handler","index","Boolean","executeNextHandler","wares","i","next","r","nextCalled","_isCacheHandler","context","outcome","_finalize","Promise","requestId","result","future","IS_FUTURE","enhanceReason","isFuture","maybe","Boolean","Promise","createDeferred","resolve","reject","promise","res","rej","upgradePromise","future","getStream","abort","onFinalize","id","lid","requester","createFuture","owner","deferred","cbs","finally","resolveStream","forEach","cb","fn","push","reason","requestId","god","identifier","createDeferred","setPromiseResult","getPromiseResult","withResponseType","obj","withReactiveResponse","withBrand"],"sources":["../../../src/request/-private/context.ts","../../../src/request/-private/promise-cache.ts","../../../src/request/-private/utils.ts","../../../src/request/-private/future.ts","../../../src/request.ts"],"sourcesContent":["import { DEBUG } from '@warp-drive/core/build-config/env';\nimport { assert } from '@warp-drive/core/build-config/macros';\n\nimport type { RequestKey } from '../../types/identifier';\nimport type { ImmutableHeaders, ImmutableRequestInfo, RequestInfo, ResponseInfo } from '../../types/request';\nimport { SkipCache } from '../../types/request';\nimport { deepFreeze } from './debug';\nimport { createDeferred } from './future';\nimport type { DeferredStream, GodContext } from './types';\n\nexport function upgradeHeaders(headers: Headers | ImmutableHeaders): ImmutableHeaders {\n  (headers as ImmutableHeaders).clone = () => {\n    return new Headers(headers);\n  };\n  (headers as ImmutableHeaders).toJSON = () => {\n    return Array.from(headers as unknown as Iterable<[string, string]>);\n  };\n  return headers as ImmutableHeaders;\n}\n\nexport function cloneResponseProperties(response: Response): ResponseInfo {\n  const { headers, ok, redirected, status, statusText, type, url } = response;\n  upgradeHeaders(headers);\n  return {\n    headers: headers as ImmutableHeaders,\n    ok,\n    redirected,\n    status,\n    statusText,\n    type,\n    url,\n  };\n}\n\nexport class ContextOwner {\n  hasSetStream = false;\n  hasSetResponse = false;\n  hasSubscribers = false;\n  stream: DeferredStream = createDeferred<ReadableStream | null>();\n  response: ResponseInfo | null = null;\n  declare request: ImmutableRequestInfo;\n  declare enhancedRequest: ImmutableRequestInfo;\n  nextCalled = 0;\n  declare god: GodContext;\n  declare controller: AbortController;\n  declare requestId: number;\n  declare isRoot: boolean;\n\n  constructor(request: RequestInfo, god: GodContext, isRoot = false) {\n    this.isRoot = isRoot;\n    this.requestId = god.id;\n    this.controller = request.controller || god.controller;\n    this.stream.promise.sizeHint = 0;\n\n    if (request.controller) {\n      if (request.controller !== god.controller) {\n        god.controller.signal.addEventListener('abort', () => {\n          this.controller.abort(god.controller.signal.reason);\n        });\n      }\n      delete request.controller;\n    }\n    let enhancedRequest: ImmutableRequestInfo = Object.assign(\n      { signal: this.controller.signal },\n      request\n    ) as ImmutableRequestInfo;\n    if (DEBUG) {\n      if (!request?.cacheOptions?.[SkipCache]) {\n        request = deepFreeze(request);\n        enhancedRequest = deepFreeze(enhancedRequest);\n      }\n    } else {\n      if (request.headers) {\n        upgradeHeaders(request.headers);\n      }\n    }\n    this.enhancedRequest = enhancedRequest;\n    this.request = request as ImmutableRequestInfo;\n    this.god = god;\n    this.stream.promise = this.stream.promise.then((stream: ReadableStream | null) => {\n      if (this.god.stream === stream && this.hasSubscribers) {\n        this.god.stream = null;\n      }\n      return stream;\n    });\n  }\n\n  get hasRequestedStream(): boolean {\n    return this.god.hasRequestedStream;\n  }\n\n  getResponse(): ResponseInfo | null {\n    if (this.hasSetResponse) {\n      return this.response;\n    }\n    if (this.nextCalled === 1) {\n      return this.god.response;\n    }\n    return null;\n  }\n  getStream(): Promise<ReadableStream | null> {\n    if (this.isRoot) {\n      this.god.hasRequestedStream = true;\n    }\n    if (!this.hasSetResponse) {\n      const hint = this.god.response?.headers?.get('content-length');\n      this.stream.promise.sizeHint = hint ? parseInt(hint, 10) : 0;\n    }\n    this.hasSubscribers = true;\n    return this.stream.promise;\n  }\n  abort(reason: DOMException): void {\n    this.controller.abort(reason);\n  }\n\n  setStream(stream: ReadableStream | Promise<ReadableStream | null> | null): void {\n    if (!this.hasSetStream) {\n      this.hasSetStream = true;\n\n      if (!(stream instanceof Promise)) {\n        this.god.stream = stream;\n      }\n      // @ts-expect-error\n      this.stream.resolve(stream);\n    }\n  }\n\n  resolveStream(): void {\n    this.setStream(this.nextCalled === 1 ? this.god.stream : null);\n  }\n\n  setResponse(response: ResponseInfo | Response | null): void {\n    if (this.hasSetResponse) {\n      if (DEBUG) {\n        throw new Error(`Cannot setResponse when a response has already been set`);\n      }\n      return;\n    }\n    this.hasSetResponse = true;\n    if (response instanceof Response) {\n      // TODO potentially avoid cloning in prod\n      let responseData = cloneResponseProperties(response);\n\n      if (DEBUG) {\n        responseData = deepFreeze(responseData);\n      }\n      this.response = responseData;\n      this.god.response = responseData;\n      const sizeHint = response.headers?.get('content-length');\n      this.stream.promise.sizeHint = sizeHint ? parseInt(sizeHint, 10) : 0;\n    } else {\n      this.response = response;\n      this.god.response = response;\n    }\n  }\n}\n\n/**\n * The context object given to each {@link Handler} (or {@link CacheHandler})\n * as it processes a request. It exposes the (immutable, enhanced) request\n * along with the methods a handler uses to build up the {@link Future} and\n * {@link StructuredDataDocument} that will ultimately be returned by the\n * {@link RequestManager}.\n *\n * @public\n */\nexport class Context {\n  /** @internal */\n  declare private ___owner: ContextOwner;\n  /**\n   * A readonly, immutable version of the request being handled, including\n   * any defaults or enhancements applied by the {@link RequestManager}.\n   *\n   * @public\n   */\n  declare request: ImmutableRequestInfo;\n  /**\n   * The id of this request as assigned by the {@link RequestManager}. Not\n   * unique across manager instances.\n   *\n   * @public\n   */\n  declare id: number;\n  /** @internal */\n  declare private _isCacheHandler: boolean;\n  /** @internal */\n  declare private _finalized: boolean;\n\n  constructor(owner: ContextOwner, isCacheHandler: boolean) {\n    this.id = owner.requestId;\n    this.___owner = owner;\n    this.request = owner.enhancedRequest;\n    this._isCacheHandler = isCacheHandler;\n    this._finalized = false;\n  }\n  /**\n   * Set the response stream for this request. May be called at most once,\n   * and may be called at any point up until the handler's `request` method\n   * resolves.\n   *\n   * @public\n   */\n  setStream(stream: ReadableStream | Promise<ReadableStream | null>): void {\n    this.___owner.setStream(stream);\n  }\n  /**\n   * Set the {@link ResponseInfo} (or raw `Response`) associated with this\n   * request. Used to populate the response information available on the\n   * resulting {@link StructuredDataDocument}.\n   *\n   * @public\n   */\n  setResponse(response: ResponseInfo | Response | null): void {\n    this.___owner.setResponse(response);\n  }\n\n  /**\n   * Associate a {@link RequestKey} with this request. May only be called\n   * synchronously from a {@link CacheHandler}.\n   *\n   * @public\n   */\n  setIdentifier(identifier: RequestKey): void {\n    assert(\n      `setIdentifier may only be used synchronously from a CacheHandler`,\n      identifier && this._isCacheHandler && !this._finalized\n    );\n    this.___owner.god.identifier = identifier;\n  }\n\n  /**\n   * Whether the application (or a downstream handler) has requested access\n   * to the response stream via {@link Future.getStream}. Handlers can use\n   * this to avoid the cost of streaming when nothing will consume it.\n   *\n   * @public\n   */\n  get hasRequestedStream(): boolean {\n    return this.___owner.hasRequestedStream;\n  }\n\n  /** @private */\n  _finalize(): void {\n    this._finalized = true;\n  }\n}\nexport type HandlerRequestContext = Context;\n","import { getOrSetUniversal } from '../../types/-private';\n\nexport type CacheResult<T = unknown, E = unknown> = { isError: true; result: E } | { isError: false; result: T };\n\n/**\n * The minimal, structural subset of the `Promise` interface required to be\n * cached and inspected by {@link setPromiseResult} / {@link getPromiseResult}\n * (and by `getPromiseState`). Anything that is at least `then`/`catch`/`finally`\n * \"shaped\" (including a real `Promise` or {@link Future}) satisfies this.\n *\n * @public\n */\nexport type Awaitable<T = unknown, E = unknown> = {\n  /**\n   * Registers fulfillment/rejection handlers, `Promise.prototype.then`-style.\n   *\n   * @public\n   */\n  then: (onFulfilled: (value: T) => unknown, onRejected: (reason: E) => unknown) => unknown;\n  /**\n   * Registers a rejection handler, `Promise.prototype.catch`-style.\n   *\n   * @public\n   */\n  catch: (onRejected: (reason: E) => unknown) => unknown;\n  /**\n   * Registers a handler run on settlement, `Promise.prototype.finally`-style.\n   *\n   * @public\n   */\n  finally: (onFinally: () => unknown) => unknown;\n};\n\nexport const PromiseCache: WeakMap<Awaitable, CacheResult> = getOrSetUniversal(\n  'PromiseCache',\n  new WeakMap<Awaitable, CacheResult>()\n);\nexport const RequestMap: Map<number, CacheResult> = getOrSetUniversal('RequestMap', new Map<number, CacheResult>());\n\nexport function setRequestResult(requestId: number, result: CacheResult): void {\n  RequestMap.set(requestId, result);\n}\nexport function clearRequestResult(requestId: number): void {\n  RequestMap.delete(requestId);\n}\nexport function getRequestResult(requestId: number): CacheResult | undefined {\n  return RequestMap.get(requestId);\n}\n\n/**\n * Cache the settled result (or error) of a promise-like value so that its\n * outcome can be synchronously read later via {@link getPromiseResult},\n * without needing to await it again.\n *\n * @public\n */\nexport function setPromiseResult(promise: Promise<unknown> | Awaitable, result: CacheResult): void {\n  PromiseCache.set(promise, result);\n}\n\n/**\n * Synchronously read the settled result (or error) previously recorded for\n * a promise-like value via {@link setPromiseResult}, if any.\n *\n * @public\n */\nexport function getPromiseResult<T, E>(promise: Promise<T> | Awaitable<T, E>): CacheResult<T, E> | undefined {\n  return PromiseCache.get(promise) as CacheResult<T, E> | undefined;\n}\n","import { DEBUG } from '@warp-drive/core/build-config/env';\n\nimport { getOrSetGlobal } from '../../types/-private';\nimport type {\n  RequestInfo,\n  StructuredDataDocument,\n  StructuredDocument,\n  StructuredErrorDocument,\n} from '../../types/request';\nimport { STRUCTURED } from '../../types/request';\nimport { Context, ContextOwner } from './context';\nimport { assertValidRequest } from './debug';\n// oxlint-disable-next-line no-unused-vars\nimport type { Fetch } from './fetch.ts';\nimport { createFuture, isFuture } from './future';\nimport { setRequestResult } from './promise-cache';\nimport type { DeferredFuture, Future, GodContext, Handler } from './types';\n\nexport const IS_CACHE_HANDLER: '___(unique) Symbol(IS_CACHE_HANDLER)' = getOrSetGlobal(\n  'IS_CACHE_HANDLER',\n  Symbol('IS_CACHE_HANDLER')\n);\n\n/**\n * A ponyfill for the global {@link DOMException} constructor.\n *\n * Some non-DOM environments (e.g. React Native, some Node/worker\n * environments) don't provide `DOMException` as a global, which would\n * otherwise throw a `ReferenceError` the first time any code referenced it\n * (for instance when classifying an abort/network error). `DOMError` falls\n * back to the global {@link Error} constructor in that case so callers can\n * uniformly use `new DOMError(...)` / `error instanceof DOMError` without\n * guarding for the global's presence themselves.\n *\n * @internal\n */\nexport const DOMError: typeof DOMException =\n  typeof DOMException !== 'undefined' ? DOMException : (Error as unknown as typeof DOMException);\nexport function curryFuture<T>(owner: ContextOwner, inbound: Future<T>, outbound: DeferredFuture<T>): Future<T> {\n  owner.setStream(inbound.getStream());\n\n  inbound.then(\n    (doc: StructuredDataDocument<T>) => {\n      const document = {\n        [STRUCTURED]: true as const,\n        request: owner.request,\n        response: doc.response,\n        content: doc.content,\n      };\n      outbound.resolve(document);\n    },\n    (error: Error & StructuredErrorDocument) => {\n      if (isDoc(error)) {\n        owner.setStream(owner.god.stream);\n      }\n      if (!error || !(error instanceof Error)) {\n        try {\n          throw new Error(error ? error : `Request Rejected with an Unknown Error`);\n        } catch (e: unknown) {\n          if (error && typeof error === 'object') {\n            Object.assign(e as Error, error);\n            (e as Error & StructuredErrorDocument).message =\n              (error as Error).message || `Request Rejected with an Unknown Error`;\n          }\n          error = e as Error & StructuredErrorDocument;\n        }\n      }\n\n      error[STRUCTURED] = true;\n      error.request = owner.request;\n      error.response = owner.getResponse();\n      error.error = error.error || error.message;\n\n      outbound.reject(error);\n    }\n  );\n  return outbound.promise;\n}\n\nfunction isDoc<T>(doc: T | StructuredDataDocument<T>): doc is StructuredDataDocument<T> {\n  return doc && (doc as StructuredDataDocument<T>)[STRUCTURED] === true;\n}\n\nfunction ensureDoc<T>(owner: ContextOwner, content: T | Error, isError: boolean): StructuredDocument<T> {\n  if (isDoc(content)) {\n    return content as StructuredDocument<T>;\n  }\n\n  if (isError) {\n    return {\n      [STRUCTURED]: true,\n      request: owner.request,\n      response: owner.getResponse(),\n      error: content as Error,\n    } as StructuredErrorDocument<T>;\n  }\n\n  return {\n    [STRUCTURED]: true,\n    request: owner.request,\n    response: owner.getResponse(),\n    content: content as T,\n  };\n}\n\n/**\n * Additional properties exposed on errors thrown by the\n * {@link Fetch | Fetch Handler}.\n *\n * In the case of an Abort or system/browser level issue,\n * this extends {@link DOMException}.\n *\n * Else it extends from {@link AggregateError} if the\n * response includes an array of errors, falling back\n * to {@link Error} as its base.\n */\nexport interface FetchError extends DOMException {\n  /**\n   * Alias for {@link FetchError.status | status}.\n   *\n   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/status)\n   */\n  code: number;\n  /**\n   * The name associated to the {@link FetchError.status | status code}.\n   *\n   * Typically this will be of the formula `StatusTextError` for instance\n   * a 404 status with status text of `Not Found` would have the name\n   * `NotFoundError`.\n   */\n  name: string;\n  /**\n   * The http status code associated to the returned error.\n   *\n   * Browser/System level network errors will often have an error code of `0` or `5`.\n   * Aborted requests will have an error code of `20`.\n   *\n   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/status)\n   */\n  status: number;\n  /**\n   * The Status Text associated to the {@link FetchError.status | status code}\n   * for the error.\n   *\n   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/statusText)\n   *\n   */\n  statusText: string;\n  /**\n   * A property signifying that an Error uses the {@link FetchError}\n   * interface.\n   */\n  isRequestError: true;\n}\n\nexport function enhanceReason(reason?: string): DOMException {\n  const error = new DOMError(reason || 'The user aborted a request.', 'AbortError');\n  // `DOMError` may be the `Error` constructor as a fallback, whose\n  // constructor doesn't accept a `name`, so set it explicitly in that case.\n  // We can't unconditionally assign `error.name` here: when `DOMError` is\n  // the real `DOMException`, `name` is already `'AbortError'` (set by its\n  // constructor) *and* `DOMException.prototype.name` is a getter-only\n  // accessor with no setter, so reassigning it throws a `TypeError` in\n  // strict-mode JS (which is how our ES modules run) - even when assigning\n  // the very same value it already holds.\n  if (error.name !== 'AbortError') {\n    (error as unknown as { name: string }).name = 'AbortError';\n  }\n  return error;\n}\n\nexport function handleOutcome<T>(\n  owner: ContextOwner,\n  inbound: Promise<T | StructuredDataDocument<T>>,\n  outbound: DeferredFuture<T>\n): Future<T> {\n  inbound.then(\n    (content: T | StructuredDataDocument<T>) => {\n      if (owner.controller.signal.aborted) {\n        // the next function did not respect the signal, we handle it here\n        outbound.reject(enhanceReason(owner.controller.signal.reason as string));\n        return;\n      }\n      if (isDoc(content)) {\n        owner.setStream(owner.god.stream);\n        content = content.content;\n      }\n      const document = {\n        [STRUCTURED]: true as const,\n        request: owner.request,\n        response: owner.getResponse(),\n        content,\n      };\n      outbound.resolve(document);\n    },\n    (error: Error & StructuredErrorDocument) => {\n      if (isDoc(error)) {\n        owner.setStream(owner.god.stream);\n      }\n      if (!error || !(error instanceof Error)) {\n        try {\n          throw new Error(error ? error : `Request Rejected with an Unknown Error`);\n        } catch (e: unknown) {\n          if (error && typeof error === 'object') {\n            Object.assign(e as Error, error);\n            (e as Error & StructuredErrorDocument).message =\n              (error as Error).message || `Request Rejected with an Unknown Error`;\n          }\n          error = e as Error & StructuredErrorDocument;\n        }\n      }\n\n      error[STRUCTURED] = true;\n      error.request = owner.request;\n      error.response = owner.getResponse();\n      error.error = error.error || error.message;\n      outbound.reject(error);\n    }\n  );\n  return outbound.promise;\n}\n\nfunction isCacheHandler(handler: Handler & { [IS_CACHE_HANDLER]?: boolean }, index: number): boolean {\n  return index === 0 && Boolean(handler[IS_CACHE_HANDLER]);\n}\n\nexport function executeNextHandler<T>(\n  wares: Readonly<Handler[]>,\n  request: RequestInfo,\n  i: number,\n  god: GodContext\n): Future<T> {\n  if (DEBUG) {\n    if (i === wares.length) {\n      throw new Error(`No handler was able to handle this request.`);\n    }\n    assertValidRequest(request, false);\n  }\n  const owner = new ContextOwner(request, god, i === 0);\n\n  function next(r: RequestInfo): Future<T> {\n    owner.nextCalled++;\n    return executeNextHandler(wares, r, i + 1, god);\n  }\n\n  const _isCacheHandler = isCacheHandler(wares[i], i);\n  const context = new Context(owner, _isCacheHandler);\n  let outcome: Promise<T | StructuredDataDocument<T>> | Future<T>;\n  try {\n    outcome = wares[i].request<T>(context, next);\n    if (_isCacheHandler) {\n      context._finalize();\n    }\n    if (!!outcome && _isCacheHandler) {\n      if (!(outcome instanceof Promise)) {\n        setRequestResult(owner.requestId, { isError: false, result: ensureDoc(owner, outcome, false) });\n        outcome = Promise.resolve(outcome);\n      }\n    } else if (DEBUG) {\n      if (!outcome || (!(outcome instanceof Promise) && !(typeof outcome === 'object' && 'then' in outcome))) {\n        // oxlint-disable-next-line no-console\n        console.log({ request, handler: wares[i], outcome });\n        if (outcome === undefined) {\n          throw new Error(`Expected handler.request to return a promise, instead received undefined.`);\n        }\n        throw new Error(`Expected handler.request to return a promise, instead received a synchronous value.`);\n      }\n    }\n  } catch (e) {\n    if (_isCacheHandler) {\n      setRequestResult(owner.requestId, { isError: true, result: ensureDoc(owner, e, true) });\n    }\n    // oxlint-disable-next-line typescript/prefer-promise-reject-errors\n    outcome = Promise.reject<StructuredDataDocument<T>>(e);\n  }\n  const future = createFuture<T>(owner);\n\n  if (isFuture<T>(outcome)) {\n    return curryFuture(owner, outcome, future);\n  }\n\n  return handleOutcome(owner, outcome, future);\n}\n","import { DEBUG } from '@warp-drive/build-config/env';\n\nimport { IS_FUTURE, type StructuredDocument } from '../../types/request';\nimport type { ContextOwner } from './context';\nimport type { Deferred, DeferredFuture, Future } from './types';\nimport { enhanceReason } from './utils';\n\nexport function isFuture<T>(maybe: unknown): maybe is Future<T> {\n  return Boolean(maybe && maybe instanceof Promise && (maybe as Future<T>)[IS_FUTURE] === true);\n}\n\n/**\n * Create a {@link Deferred}: a promise along with the `resolve`/`reject`\n * callbacks that settle it, so the promise can be handed out before the\n * work that will settle it has started.\n *\n * @public\n */\nexport function createDeferred<T>(): Deferred<T> {\n  let resolve!: (v: T) => void;\n  let reject!: (v: unknown) => void;\n  const promise = new Promise<T>((res, rej) => {\n    resolve = res;\n    reject = rej;\n  });\n  return { resolve, reject, promise };\n}\n\nexport function upgradePromise<T>(promise: Promise<StructuredDocument<T>>, future: Future<T>): Future<T> {\n  (promise as Future<T>)[IS_FUTURE] = true;\n  // oxlint-disable-next-line typescript/unbound-method\n  (promise as Future<T>).getStream = future.getStream;\n  // oxlint-disable-next-line typescript/unbound-method\n  (promise as Future<T>).abort = future.abort;\n  // oxlint-disable-next-line typescript/unbound-method\n  (promise as Future<T>).onFinalize = future.onFinalize;\n  (promise as Future<T>).id = future.id;\n  (promise as Future<T>).lid = future.lid;\n  (promise as Future<T>).requester = future.requester;\n\n  if (DEBUG) {\n    // @ts-expect-error\n    promise.toJSON = () => {\n      const id = 'Future<' + (promise as Future<T>).id + '>';\n      if ((promise as Future<T>).lid) {\n        return `${id} (${(promise as Future<T>).lid!.lid})`;\n      }\n      return id;\n    };\n  }\n\n  return promise as Future<T>;\n}\n\nexport function createFuture<T>(owner: ContextOwner): DeferredFuture<T> {\n  const deferred = createDeferred<T>() as unknown as DeferredFuture<T>;\n  let { promise } = deferred;\n  let cbs: Array<() => void> | undefined;\n  promise = promise.finally(() => {\n    owner.resolveStream();\n    if (cbs) {\n      cbs.forEach((cb) => cb());\n    }\n  }) as Future<T>;\n  promise.onFinalize = (fn: () => void) => {\n    cbs = cbs || [];\n    cbs.push(fn);\n  };\n  promise[IS_FUTURE] = true;\n  promise.getStream = () => {\n    return owner.getStream();\n  };\n  promise.abort = (reason?: string) => {\n    owner.abort(enhanceReason(reason));\n  };\n  promise.id = owner.requestId;\n  promise.lid = owner.god.identifier;\n  promise.requester = owner.god.requester;\n\n  if (DEBUG) {\n    // @ts-expect-error\n    promise.toJSON = () => {\n      const id = 'Future<' + promise.id + '>';\n      if (promise.lid) {\n        return `${id} (${promise.lid.lid})`;\n      }\n      return id;\n    };\n  }\n\n  deferred.promise = promise;\n  return deferred;\n}\n","import type { ReactiveDataDocument } from './reactive.ts';\nimport type { RequestInfo } from './types/request.ts';\nimport type { RequestSignature } from './types/symbols.ts';\n\nexport { createDeferred } from './request/-private/future.ts';\nexport type {\n  Future,\n  Handler,\n  CacheHandler,\n  NextFn,\n  Deferred,\n  ManagedRequestPriority,\n} from './request/-private/types.ts';\nexport { setPromiseResult, getPromiseResult } from './request/-private/promise-cache.ts';\nexport type { Awaitable } from './request/-private/promise-cache.ts';\nexport type { Context } from './request/-private/context.ts';\n\n/**\n * Brands the supplied object with the supplied response type.\n *\n * ```ts\n * import type { ReactiveDataDocument } from '@warp-drive/core/reactive';\n * import { withResponseType } from '@warp-drive/core/request';\n * import type { User } from '#/data/user.ts'\n *\n * const result = await store.request(\n *  withResponseType<ReactiveDataDocument<User>>({ url: '/users/1' })\n * );\n *\n * result.content.data; // will have type User\n * ```\n *\n */\nexport function withResponseType<T>(obj: RequestInfo): RequestInfo<T> & {\n  /** The branded response type. Present only at the type level; carries no runtime value. */\n  [RequestSignature]: T;\n} {\n  return obj as RequestInfo<T> & {\n    [RequestSignature]: T;\n  };\n}\n\n/**\n * Brands the supplied object with the supplied response type\n * wrapped in {@link ReactiveDataDocument}. This is a convenience for\n * the common case of using {@link withResponseType} with `ReactiveDataDocument`.\n *\n * ```ts\n * import { withReactiveResponse } from '@warp-drive/core/request';\n * import type { User } from '#/data/user.ts'\n *\n * const result = await store.request(\n *   withReactiveResponse<User>({ url: '/users/1' })\n * );\n *\n * result.content.data; // will have type User\n * ```\n *\n * @public\n */\nexport function withReactiveResponse<T>(obj: RequestInfo): RequestInfo<ReactiveDataDocument<T>> & {\n  /** The branded response type. Present only at the type level; carries no runtime value. */\n  [RequestSignature]: ReactiveDataDocument<T>;\n} {\n  return obj as RequestInfo<ReactiveDataDocument<T>> & {\n    [RequestSignature]: ReactiveDataDocument<T>;\n  };\n}\n\n/**\n * @deprecated use {@link withResponseType} instead\n */\nexport const withBrand: typeof withResponseType = withResponseType;\n"],"mappings":"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"}

package/dist/unpkg/prod/request.js

@@ -1,3 +1,3 @@
-import { f as setPromiseResult, i as createDeferred, n as withReactiveResponse, r as withResponseType, t as withBrand, u as getPromiseResult } from "./request-BcJNzSgv.js";
+import { f as setPromiseResult, i as createDeferred, n as withReactiveResponse, r as withResponseType, t as withBrand, u as getPromiseResult } from "./request-BoeppjDj.js";
 
 export { createDeferred, getPromiseResult, setPromiseResult, withBrand, withReactiveResponse, withResponseType };

package/dist/unpkg/prod/signals/-leaked.js

@@ -1,3 +1,3 @@
-import { E as waitFor, S as withSignalStore, b as notifyInternalSignal, c as defineSignal, d as gate, f as memoized, n as DISPOSE, o as defineGate, p as signal, s as defineNonEnumerableSignal, u as entangleSignal, v as getOrCreateInternalSignal, x as peekInternalSignal, y as makeInitializer } from "../-private-TNaS5Piv.js";
+import { D as notifyInternalSignal, E as makeInitializer, N as waitFor, O as peekInternalSignal, T as getOrCreateInternalSignal, _ as entangleSignal, a as getPaginationState, b as signal, c as getPaginationCache, h as defineSignal, i as getPaginationLinks, k as withSignalStore, l as DISPOSE, m as defineNonEnumerableSignal, n as createPaginationLinksSubscription, o as clearPaginationCache, p as defineGate, r as createPaginationSubscription, s as defaultPageHints, v as gate, y as memoized } from "../-private-ggVX_Iob.js";
 
-export { DISPOSE, defineGate, defineNonEnumerableSignal, defineSignal, entangleSignal, gate, getOrCreateInternalSignal, makeInitializer, memoized, notifyInternalSignal, peekInternalSignal, signal, waitFor, withSignalStore };
+export { DISPOSE, clearPaginationCache, createPaginationLinksSubscription, createPaginationSubscription, defaultPageHints, defineGate, defineNonEnumerableSignal, defineSignal, entangleSignal, gate, getOrCreateInternalSignal, getPaginationCache, getPaginationLinks, getPaginationState, makeInitializer, memoized, notifyInternalSignal, peekInternalSignal, signal, waitFor, withSignalStore };

package/dist/unpkg/prod/{src-Dzz-j6pp.js → src-C0wuASrN.js}

@@ -1,8 +1,8 @@
-import { a as setTransient, i as peekUniversalTransient, o as setUniversalTransient, r as peekTransient, t as getOrSetGlobal } from "./-private-BK71-uXR.js";
-import { C as ARRAY_SIGNAL, D as willSyncFlushWatchers, S as withSignalStore, _ as createInternalSignal, a as createSignalDescriptor, b as notifyInternalSignal, c as defineSignal, g as createInternalMemo, h as consumeInternalSignal, l as entangleInitiallyStaleSignal, m as Signals, o as defineGate, u as entangleSignal, v as getOrCreateInternalSignal, w as OBJECT_SIGNAL, x as peekInternalSignal } from "./-private-TNaS5Piv.js";
+import { a as setTransient, i as peekUniversalTransient, o as setUniversalTransient, r as peekTransient, t as getOrSetGlobal } from "./-private-B6aLbrgV.js";
+import { A as ARRAY_SIGNAL, C as createInternalMemo, D as notifyInternalSignal, O as peekInternalSignal, P as willSyncFlushWatchers, S as consumeInternalSignal, T as getOrCreateInternalSignal, _ as entangleSignal, f as createSignalDescriptor, g as entangleInitiallyStaleSignal, h as defineSignal, j as OBJECT_SIGNAL, k as withSignalStore, p as defineGate, w as createInternalSignal, x as Signals } from "./-private-ggVX_Iob.js";
 import { EnableHydration, STRUCTURED, SkipCache } from "./types/request.js";
-import { a as upgradePromise, c as executeNextHandler, d as getRequestResult, f as setPromiseResult, l as clearRequestResult, o as DOMError, p as cloneResponseProperties, s as IS_CACHE_HANDLER, t as withBrand } from "./request-BcJNzSgv.js";
-import { a as SOURCE, i as Destroy, n as Commit, r as Context, t as Checkout } from "./-private-Z9i0icpE.js";
+import { a as upgradePromise, c as executeNextHandler, d as getRequestResult, f as setPromiseResult, l as clearRequestResult, o as DOMError, p as cloneResponseProperties, s as IS_CACHE_HANDLER, t as withBrand } from "./request-BoeppjDj.js";
+import { a as SOURCE, i as Destroy, n as Commit, r as Context, t as Checkout } from "./-private-8gd8hbwm.js";
 import { CACHE_OWNER } from "./types/identifier.js";
 import { RecordStore, Type } from "./types/symbols.js";
 import { isResourceSchema } from "./types/schema/fields.js";
@@ -141,13 +141,18 @@ var CacheCapabilitiesManager = class {
 		return this.cacheKeyManager;
 	}
 	/** @internal */
-	_scheduleNotification(identifier, key) {
+	_scheduleNotification(identifier, key, channel) {
 		let pending = this._pendingNotifies.get(identifier);
 		if (!pending) {
-			pending = /* @__PURE__ */ new Set();
+			pending = /* @__PURE__ */ new Map();
 			this._pendingNotifies.set(identifier, pending);
 		}
-		pending.add(key);
+		let channels = pending.get(key);
+		if (!channels) {
+			channels = /* @__PURE__ */ new Set();
+			pending.set(key, channels);
+		}
+		channels.add(channel);
 		if (this._willNotify === true) return;
 		this._willNotify = true;
 		if (this._store._cbs) this._store._schedule("notify", () => this._flushNotifications());
@@ -159,16 +164,29 @@ var CacheCapabilitiesManager = class {
 		const pending = this._pendingNotifies;
 		this._pendingNotifies = /* @__PURE__ */ new Map();
 		this._willNotify = false;
-		pending.forEach((set, identifier) => {
-			this._store.notifications.notify(identifier, "relationships", set);
+		pending.forEach((channelsByKey, identifier) => {
+			const keysByChannel = /* @__PURE__ */ new Map();
+			channelsByKey.forEach((channels, key) => {
+				channels.forEach((channel) => {
+					let keys = keysByChannel.get(channel);
+					if (!keys) {
+						keys = /* @__PURE__ */ new Set();
+						keysByChannel.set(channel, keys);
+					}
+					keys.add(key);
+				});
+			});
+			keysByChannel.forEach((keys, channel) => {
+				this._store.notifications.notify(identifier, "relationships", keys, channel);
+			});
 		});
 	}
-	notifyChange(identifier, namespace, key) {
+	notifyChange(identifier, namespace, key, channel) {
 		if (namespace === "relationships" && key) {
-			this._scheduleNotification(identifier, key);
+			this._scheduleNotification(identifier, key, channel);
 			return;
 		}
-		this._store.notifications.notify(identifier, namespace, key);
+		this._store.notifications.notify(identifier, namespace, key, channel);
 	}
 	get schema() {
 		return this._store.schema;
@@ -1032,49 +1050,141 @@ function isCacheOperationValue(value) {
 	return value === "added" || value === "state" || value === "updated" || value === "removed" || value === "invalidated";
 }
 /**
+* The full set of notification kinds the {@link NotificationManager} can emit for a resource,
+* including both {@link CacheOperation}s and finer-grained field-level change notifications.
+*/
+/**
+* The shape accepted by {@link NotificationManager.notify} and
+* {@link CacheCapabilitiesManager.notifyChange} for delivering many keys for
+* the `'attributes'` or `'relationships'` namespaces in a single call
+* instead of once per key.
+*
+* @since 5.9.0
+* @public
+*/
+/**
+* A change to a resource's `attributes` or `relationships` can be relevant to
+* a "local" view of the resource (its mutable/editable state), a "remote" view
+* (its last-known-persisted state), or both.
+*
+* Each view subscribes to its own channel and, when notified, re-pulls its own
+* projection of the data: a remote-only reader (e.g. PolarisMode's default
+* immutable record) subscribes `'remote'` and re-reads remote state; an
+* editable/reconciled reader (a legacy record, or an editable checkout)
+* subscribes `'local'` (the same as omitting the channel) and re-reads local
+* state. A notifier that knows which projection changed tags the notification
+* with that channel; each tag is delivered only to that channel's subscribers.
+* A change affecting both projections is either notified unscoped or once per
+* channel. An unscoped notify cannot guarantee which view changed, so it
+* reaches every subscriber -- this keeps every pre-channel `notify` callsite
+* (and any custom cache that doesn't know about channels) fully compatible.
+*
+* The full delivery matrix:
+*
+* | notify ↓ subscribe → | `'local'` | `'remote'` | omitted (= `'local'`) |
+* | -------------------- | --------- | ---------- | --------------------- |
+* | `'local'`            | ✅        | ❌         | ✅                    |
+* | `'remote'`           | ❌        | ✅         | ❌                    |
+* | omitted              | ✅        | ✅         | ✅                    |
+*
+* Channel only applies to the `'attributes'` and `'relationships'`
+* notification types. All other types (`'errors'`,
+* `'identity'`, `'state'`, and the various `CacheOperation`/
+* `DocumentCacheOperation` values) are never filtered by channel since they
+* have no local/remote duality.
+*
+* @public
+*/
+/**
+* Well-known sentinel recorded in a {@link ChannelSet} for a touch that
+* carried no channel. An unscoped touch always reaches every subscriber
+* regardless of what channel(s) the same key was also touched with, so its
+* presence in the set short-circuits channel filtering.
+*/
+const UnscopedChannel = getOrSetGlobal("UnscopedChannel", Symbol("unscoped"));
+/**
 * Merges an incoming `notify()` call for a single identifier into that
 * identifier's pending-notifications buffer, coalescing redundant work within
 * a single flush window.
 *
 * The buffer is a `Map` from namespace (`'attributes'`, `'relationships'`,
-* `'state'`, etc.) to either a `Set<string>` of pending keys or `null`. Using
-* a `Map` means the *first* time a namespace is touched during this flush
-* window fixes its position in iteration order; every subsequent touch to
-* that same namespace (regardless of how much later, or how many other
-* namespaces fired in between) updates its value in place without moving it.
-* This preserves the relative order in which *different* namespaces first
-* fired, while intentionally not tracking the arrival order of repeated
-* touches to the *same* namespace - those are provably safe to coalesce
-* because subscribers never receive anything about a notification beyond
-* `(cacheKey, type, key?)`.
-*
-* For `'attributes'`/`'relationships'`, `null` is a wildcard meaning "an
-* unspecified set of keys changed" - a strict superset of any specific key
-* list, per the existing contract of {@link CacheCapabilitiesManager.notifyChange}.
-* A keyless call always upgrades the bucket to `null`, discarding any
-* specific keys already collected; a keyed call is a no-op once the bucket
-* is already `null`.
-*
-* For every other namespace, subscriber callbacks never receive a key at
-* all, so `null` is used purely as a "this namespace fired at least once"
-* presence marker; multiple firings within one flush all collapse to the
-* same single marker.
+* `'state'`, etc.) to a "bucket". Using a `Map` means the *first* time a
+* namespace is touched during this flush window fixes its position in
+* iteration order; every subsequent touch to that same namespace (regardless
+* of how much later, or how many other namespaces fired in between) updates
+* its value in place without moving it. This preserves the relative order in
+* which *different* namespaces first fired, while intentionally not tracking
+* the arrival order of repeated touches to the *same* namespace - those are
+* provably safe to coalesce because subscribers never receive anything about
+* a notification beyond `(cacheKey, type, key?)`.
+*
+* For every namespace other than `'attributes'`/`'relationships'`, subscriber
+* callbacks never receive a key at all (and channel never applies to them -
+* see {@link NotificationChannel}), so the bucket is simply `null`, used
+* purely as a "this namespace fired at least once" presence marker; multiple
+* firings within one flush all collapse to the same single marker.
+*
+* For `'attributes'`/`'relationships'`, a key (or channel) *does* matter, so
+* the bucket is one of:
+* - a `Map<string, ChannelSet>`: the normal case, mapping each specific key
+*   touched to the set of channels it was touched with ({@link UnscopedChannel}
+*   in that set means at least one of those touches was itself unscoped).
+* - a `ChannelSet` directly: a wildcard meaning "an unspecified set of keys
+*   changed" - a strict superset of any specific key list, per the existing
+*   contract of {@link CacheCapabilitiesManager.notifyChange} - tagged with
+*   the set of channels any of the coalesced keyless (or post-wildcard
+*   keyed) touches carried.
+*
+* A keyless call always upgrades the bucket to the wildcard form. When
+* upgrading away from a `Map`, every channel ever recorded against any of
+* its specific keys is folded into the new wildcard `ChannelSet` - the
+* wildcard must remain a superset not just key-wise but channel-wise too, or
+* a channel-scoped subscriber that would have heard about one of those
+* specific keys could silently stop hearing about it once the bucket flips
+* to wildcard. Once a bucket is a wildcard it can never downgrade back to a
+* `Map`; a keyed touch that arrives after that point still folds its channel
+* into the wildcard's `ChannelSet` (the specific key itself is discarded,
+* since the wildcard already covers it).
 */
-function mergeIntoBuffer(buffer, value, key) {
+function mergeIntoBuffer(buffer, value, key, channel) {
 	if (value !== "attributes" && value !== "relationships") {
 		buffer.set(value, null);
 		return;
 	}
 	const existing = buffer.get(value);
 	if (key === null || key === void 0) {
-		buffer.set(value, null);
+		const channels = existing instanceof Set ? existing : /* @__PURE__ */ new Set();
+		if (existing instanceof Map) for (const channelsForKey of existing.values()) for (const ch of channelsForKey) channels.add(ch);
+		channels.add(channel ?? UnscopedChannel);
+		buffer.set(value, channels);
+		return;
+	}
+	if (existing instanceof Set) {
+		existing.add(channel ?? UnscopedChannel);
 		return;
 	}
-	if (existing === null) return;
-	const set = existing ?? /* @__PURE__ */ new Set();
-	if (!existing) buffer.set(value, set);
-	if (key instanceof Set) for (const k of key) set.add(k);
-	else set.add(key);
+	const map = existing ?? /* @__PURE__ */ new Map();
+	if (!existing) buffer.set(value, map);
+	const keys = key instanceof Set ? key : [key];
+	for (const k of keys) {
+		let channels = map.get(k);
+		if (!channels) {
+			channels = /* @__PURE__ */ new Set();
+			map.set(k, channels);
+		}
+		channels.add(channel ?? UnscopedChannel);
+	}
+}
+/**
+* Given the set of channels a touch (or coalesced group of touches) was
+* recorded with, determines whether a subscriber scoped to `subscriberChannel`
+* should be delivered to (see the delivery matrix on
+* {@link NotificationChannel}): a subscriber hears a touch-set if any of its
+* touches was unscoped or tagged with the subscriber's own channel; a
+* touch-set exclusively tagged with the *other* channel is skipped.
+*/
+function shouldDeliverToChannel(channels, subscriberChannel) {
+	return channels.has(UnscopedChannel) || channels.has(subscriberChannel);
 }
 function _unsubscribe(token, cache) {
 	const cacheKey = token.for;
@@ -1132,12 +1242,26 @@ var NotificationManager = class {
 	* }
 	* ```
 	*
+	* A `channel` may be provided when subscribing to a `ResourceKey`. Its
+	* effect is that the subscription skips `'attributes'`/`'relationships'`
+	* notifications explicitly tagged with the *other* channel; unscoped
+	* notifications, and notifications for all other notification types, always
+	* reach the subscriber. Subscribing `'local'` and omitting the channel are
+	* the same thing. See {@link NotificationChannel}.
+	*
+	* | notify ↓ subscribe → | `'local'` | `'remote'` | omitted (= `'local'`) |
+	* | -------------------- | --------- | ---------- | --------------------- |
+	* | `'local'`            | ✅        | ❌         | ✅                    |
+	* | `'remote'`           | ❌        | ✅         | ❌                    |
+	* | omitted              | ✅        | ✅         | ✅                    |
+	*
 	* @public
 	* @return an opaque token to be used with unsubscribe
 	*/
-	subscribe(cacheKey, callback) {
+	subscribe(cacheKey, callback, channel) {
 		let callbacks = this._cache.get(cacheKey);
 		callback.for = cacheKey;
+		callback.channel = channel ?? "local";
 		if (!callbacks) {
 			callbacks = [];
 			this._cache.set(cacheKey, callbacks);
@@ -1167,9 +1291,22 @@ var NotificationManager = class {
 	* buffer/flush scheduling) only once for the whole batch instead of once
 	* per key.
 	*
+	* A `channel` may be supplied for the `'attributes'`/`'relationships'`
+	* namespaces. Tagging a notification `'local'` declares "only the local
+	* (reconciled/editable) view changed"; tagging it `'remote'` declares "only
+	* the remote view changed". Each tag is delivered only to that channel's
+	* subscribers. Omitting the channel reaches every subscriber regardless of
+	* its channel. See {@link NotificationChannel}.
+	*
+	* | notify ↓ subscribe → | `'local'` | `'remote'` | omitted (= `'local'`) |
+	* | -------------------- | --------- | ---------- | --------------------- |
+	* | `'local'`            | ✅        | ❌         | ✅                    |
+	* | `'remote'`           | ❌        | ✅         | ❌                    |
+	* | omitted              | ✅        | ✅         | ✅                    |
+	*
 	* @private
 	*/
-	notify(cacheKey, value, key) {
+	notify(cacheKey, value, key, channel) {
 		if (this.isDestroyed) return false;
 		if (!isResourceKey(cacheKey) && !isRequestKey(cacheKey)) return false;
 		const _hasSubscribers = hasSubscribers(this._cache, cacheKey, value);
@@ -1179,7 +1316,7 @@ var NotificationManager = class {
 				buffer = /* @__PURE__ */ new Map();
 				this._buffered.set(cacheKey, buffer);
 			}
-			mergeIntoBuffer(buffer, value, key);
+			mergeIntoBuffer(buffer, value, key, channel);
 			if (!this._scheduleNotify()) {}
 		}
 		return _hasSubscribers;
@@ -1206,8 +1343,9 @@ var NotificationManager = class {
 		const buffered = this._buffered;
 		if (buffered.size) {
 			this._buffered = /* @__PURE__ */ new Map();
-			for (const [cacheKey, states] of buffered) for (const [value, keyOrKeys] of states) if (keyOrKeys === null) _flushNotification(this._cache, cacheKey, value, null);
-			else for (const key of keyOrKeys) _flushNotification(this._cache, cacheKey, value, key);
+			for (const [cacheKey, states] of buffered) for (const [value, bucket] of states) if (bucket === null) _flushNotification(this._cache, cacheKey, value, null);
+			else if (bucket instanceof Set) _flushNotification(this._cache, cacheKey, value, null, bucket);
+			else for (const [key, channels] of bucket) _flushNotification(this._cache, cacheKey, value, key, channels);
 		}
 		this._hasFlush = false;
 		this._onFlushCB?.();
@@ -1226,7 +1364,7 @@ var NotificationManager = class {
 *
 * @private
 */
-function _flushNotification(cache, cacheKey, value, key) {
+function _flushNotification(cache, cacheKey, value, key, channels) {
 	if (isCacheOperationValue(value)) {
 		const callbackMap = cache.get(isRequestKey(cacheKey) ? "document" : "resource");
 		if (callbackMap) callbackMap.forEach((cb) => {
@@ -1236,6 +1374,10 @@ function _flushNotification(cache, cacheKey, value, key) {
 	const callbacks = cache.get(cacheKey);
 	if (!callbacks || !callbacks.length) return false;
 	callbacks.forEach((cb) => {
+		if (channels) {
+			const subscriberChannel = cb.channel;
+			if (!shouldDeliverToChannel(channels, subscriberChannel)) return;
+		}
 		cb(cacheKey, value, key);
 	});
 	return true;
@@ -2065,7 +2207,7 @@ var RecordArrayManager = class {
 	}
 	getCollection(config) {
 		if ("requestKey" in config && this._keyedArrays.has(config.requestKey.lid)) return this._keyedArrays.get(config.requestKey.lid);
-		let array = null;
+		let array;
 		if ("requestKey" in config) {
 			const options = {
 				store: this.store,
@@ -2845,7 +2987,7 @@ var Store = class extends BaseClass {
 		this._join(() => {
 			const normalizedModelName = normalizeModelName(type);
 			const properties = { ...inputProperties };
-			let id = null;
+			let id;
 			if (properties.id === null || properties.id === void 0) {
 				const adapter = this.adapterFor?.(normalizedModelName, true);
 				if (adapter && adapter.generateIdForRecord) id = properties.id = coerceId(adapter.generateIdForRecord(this, normalizedModelName, properties));
@@ -4426,7 +4568,7 @@ var ManyArrayManager = class {
 		if (rawValue.meta) array.meta = rawValue.meta;
 		if (rawValue.links) array.links = rawValue.links;
 		const currentState = array[Context].source;
-		if (currentState !== rawValue.data) {
+		if (rawValue.data !== void 0 && currentState !== rawValue.data) {
 			currentState.length = 0;
 			fastPush(currentState, rawValue.data);
 		}
@@ -4478,7 +4620,7 @@ function getHasManyField(context) {
 		if (cached) return cached;
 		const { editable, resourceKey } = context;
 		const { cache } = store;
-		const rawValue = cache.getRelationship(resourceKey, getFieldCacheKeyStrict(field));
+		const rawValue = editable ? cache.getRelationship(resourceKey, getFieldCacheKeyStrict(field)) : cache.getRemoteRelationship(resourceKey, getFieldCacheKeyStrict(field));
 		if (!rawValue) return null;
 		const managedArray = createLegacyManyArray({
 			store,
@@ -5047,7 +5189,7 @@ var ReactiveResource = class ReactiveResource {
 					}
 				}
 			}
-		});
+		}, context.legacy || context.editable ? "local" : "remote");
 		const proxy = new Proxy(this, {
 			ownKeys() {
 				const identityKey = identityField?.name;
@@ -6311,6 +6453,7 @@ const ERROR_STATUS_CODE_FOR = /* @__PURE__ */ new Map([
 * ```
 *
 * @public
+* @badge Handler
 */
 const Fetch = { 
 /**
@@ -6796,4 +6939,4 @@ function useRecommendedStore(options, StoreKlass = Store) {
 
 //#endregion
 export { coerceId as A, isResourceKey as C, setIdentifierUpdateMethod as D, setIdentifierResetMethod as E, setRecordIdentifier as F, storeFor as I, assertPrivateCapabilities as L, StoreMap as M, _clearCaches as N, setKeyInfoForResource as O, recordIdentifierFor as P, isRequestKey as S, setIdentifierGenerationMethod as T, Store as _, fromIdentity as a, RecordArrayManager as b, instantiateRecord as c, commit as d, log as f, CacheHandler as g, constructResource as h, SchemaService as i, ensureStringId as j, normalizeModelName as k, teardownRecord as l, createLegacyManyArray as m, RequestManager as n, registerDerivations as o, logGroup as p, Fetch as r, withDefaults as s, useRecommendedStore as t, checkout as u, assertPrivateStore as v, setIdentifierForgetMethod as w, fastPush as x, isPrivateStore as y };
-//# sourceMappingURL=src-Dzz-j6pp.js.map
+//# sourceMappingURL=src-C0wuASrN.js.map