@opetope/core 0.1.0

package/dist/reactive.d.ts

@@ -0,0 +1,41 @@
+import type { Lookup } from './reactive-collection.js';
+import type { Equality, ExternalReadableSource, ReactiveRead } from './reactive-scheduler.js';
+import type { Readable } from './readable.js';
+type ReadableValue<Source> = Source extends Readable<infer Value> ? Value : never;
+type ReadableValues<Sources extends readonly Readable<unknown>[]> = {
+    readonly [Index in keyof Sources]: ReadableValue<Sources[Index]>;
+};
+interface ComputedOptions<Value> {
+    readonly equals?: Equality<Value>;
+    readonly read: (get: ReactiveRead) => Value;
+}
+interface DeriveOptions<Source, Value> {
+    readonly equals?: Equality<Value>;
+    readonly from: Readable<Source>;
+    readonly select: (source: Source) => Value;
+}
+interface DeriveManyOptions<Sources extends readonly Readable<unknown>[], Value> {
+    readonly equals?: Equality<Value>;
+    readonly from: Sources;
+    readonly select: (...sources: ReadableValues<Sources>) => Value;
+}
+declare function computed<Value>(options: ComputedOptions<Value>): Readable<Value>;
+declare function isReadable(value: unknown): value is Readable<unknown>;
+interface FromOptionalOptions<Value> {
+    readonly equals?: Equality<Value>;
+    /** What the consumer reads while the provider is absent: a weak edge answers, it does not fail (D105). */
+    readonly missing: Value;
+}
+/**
+ * D187: the data half of a weak edge. `select` runs only on a `found` lookup and may return either a value or the
+ * provider's own `Readable`; the nested readable is read through `get`, so it is tracked while the provider is there
+ * and released the moment the lookup goes back to `missing`. A new provider instance is a new lookup, so the
+ * selection follows it without the consumer holding the old one.
+ */
+declare function fromOptional<Found, Value>(source: Readable<Lookup<Found>>, select: (found: Found) => Readable<Value> | Value, options: FromOptionalOptions<Value>): Readable<Value>;
+declare function derive<Source, Value>(options: DeriveOptions<Source, Value>): Readable<Value>;
+declare function derive<Sources extends readonly Readable<unknown>[], Value>(options: DeriveManyOptions<Sources, Value>): Readable<Value>;
+declare function externalReadable<Value>(source: ExternalReadableSource<Value>): Readable<Value>;
+declare function externalReadable<Source, Value>(source: ExternalReadableSource<Source>, select: (source: Source) => Value, equals?: Equality<Value>): Readable<Value>;
+export { computed, derive, externalReadable, fromOptional, isReadable };
+export type { ComputedOptions, DeriveManyOptions, DeriveOptions, Equality, ExternalReadableSource, ReactiveRead, ReadableValue, ReadableValues, };

package/dist/reactive.js

@@ -0,0 +1,2 @@
+import{reactiveComputed as i,defaultEquality as a,reactiveDerived as f,reactiveExternal as o}from"./reactive-scheduler.js";function s(e){return i(e.read,e.equals??a)}function l(e){if(typeof e!="object"||e===null)return!1;const r=e;return typeof r.getSnapshot=="function"&&typeof r.subscribe=="function"}function d(e,r,n){return s({...n.equals===void 0?{}:{equals:n.equals},read:t=>{const u=t(e);if(u.kind==="missing")return n.missing;const c=r(u.value);return l(c)?t(c):c}})}function m(e){if(l(e.from)){const t=e.from,u=e.select;return f([t],c=>u(c(t)),e.equals??a)}const r=[...e.from],n=e.select;return f(r,t=>n(...r.map(u=>t(u))),e.equals??a)}function q(e,r,n){return o(e,r??(t=>t),n??a)}export{s as computed,m as derive,q as externalReadable,d as fromOptional,l as isReadable};
+//# sourceMappingURL=reactive.js.map

package/dist/reactive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactive.js","sources":["../src/reactive.ts"],"sourcesContent":["import type { Lookup } from './reactive-collection';\nimport { defaultEquality, reactiveComputed, reactiveDerived, reactiveExternal } from './reactive-scheduler';\nimport type { Equality, ExternalReadableSource, ReactiveRead } from './reactive-scheduler';\nimport type { Readable } from './readable';\n\ntype ReadableValue<Source> = Source extends Readable<infer Value> ? Value : never;\ntype ReadableValues<Sources extends readonly Readable<unknown>[]> = {\n  readonly [Index in keyof Sources]: ReadableValue<Sources[Index]>;\n};\n\ninterface ComputedOptions<Value> {\n  readonly equals?: Equality<Value>;\n  readonly read: (get: ReactiveRead) => Value;\n}\n\ninterface DeriveOptions<Source, Value> {\n  readonly equals?: Equality<Value>;\n  readonly from: Readable<Source>;\n  readonly select: (source: Source) => Value;\n}\n\ninterface DeriveManyOptions<Sources extends readonly Readable<unknown>[], Value> {\n  readonly equals?: Equality<Value>;\n  readonly from: Sources;\n  readonly select: (...sources: ReadableValues<Sources>) => Value;\n}\n\nfunction computed<Value>(options: ComputedOptions<Value>): Readable<Value> {\n  return reactiveComputed(options.read, options.equals ?? defaultEquality);\n}\n\nfunction isReadable(value: unknown): value is Readable<unknown> {\n  if (typeof value !== 'object' || value === null) return false;\n\n  const readable = value as Partial<Readable<unknown>>;\n\n  return typeof readable.getSnapshot === 'function' && typeof readable.subscribe === 'function';\n}\n\ninterface FromOptionalOptions<Value> {\n  readonly equals?: Equality<Value>;\n  /** What the consumer reads while the provider is absent: a weak edge answers, it does not fail (D105). */\n  readonly missing: Value;\n}\n\n/**\n * D187: the data half of a weak edge. `select` runs only on a `found` lookup and may return either a value or the\n * provider's own `Readable`; the nested readable is read through `get`, so it is tracked while the provider is there\n * and released the moment the lookup goes back to `missing`. A new provider instance is a new lookup, so the\n * selection follows it without the consumer holding the old one.\n */\nfunction fromOptional<Found, Value>(\n  source: Readable<Lookup<Found>>,\n  select: (found: Found) => Readable<Value> | Value,\n  options: FromOptionalOptions<Value>,\n): Readable<Value> {\n  return computed({\n    ...(options.equals === undefined ? {} : { equals: options.equals }),\n    read: get => {\n      const lookup = get(source);\n\n      if (lookup.kind === 'missing') return options.missing;\n\n      const selected = select(lookup.value);\n\n      return isReadable(selected) ? get(selected) : selected;\n    },\n  });\n}\n\nfunction derive<Source, Value>(options: DeriveOptions<Source, Value>): Readable<Value>;\nfunction derive<Sources extends readonly Readable<unknown>[], Value>(\n  options: DeriveManyOptions<Sources, Value>,\n): Readable<Value>;\nfunction derive<Value>(\n  options: DeriveManyOptions<readonly Readable<unknown>[], Value> | DeriveOptions<unknown, Value>,\n): Readable<Value> {\n  if (isReadable(options.from)) {\n    const source = options.from;\n    const select = (options as DeriveOptions<unknown, Value>).select;\n\n    return reactiveDerived([source], get => select(get(source)), options.equals ?? defaultEquality);\n  }\n\n  const sources = [...options.from];\n  const select = (options as DeriveManyOptions<readonly Readable<unknown>[], Value>).select;\n\n  return reactiveDerived(\n    sources,\n    get => select(...sources.map(source => get(source))),\n    options.equals ?? defaultEquality,\n  );\n}\n\nfunction externalReadable<Value>(source: ExternalReadableSource<Value>): Readable<Value>;\nfunction externalReadable<Source, Value>(\n  source: ExternalReadableSource<Source>,\n  select: (source: Source) => Value,\n  equals?: Equality<Value>,\n): Readable<Value>;\nfunction externalReadable<Source, Value = Source>(\n  source: ExternalReadableSource<Source>,\n  select?: (source: Source) => Value,\n  equals?: Equality<Value>,\n): Readable<Source | Value> {\n  return reactiveExternal(\n    source,\n    (select ?? ((value: Source) => value)) as (source: Source) => Source | Value,\n    (equals ?? defaultEquality) as Equality<Source | Value>,\n  );\n}\n\nexport { computed, derive, externalReadable, fromOptional, isReadable };\nexport type {\n  ComputedOptions,\n  DeriveManyOptions,\n  DeriveOptions,\n  Equality,\n  ExternalReadableSource,\n  ReactiveRead,\n  ReadableValue,\n  ReadableValues,\n};\n"],"names":["computed","options","reactiveComputed","defaultEquality","isReadable","value","readable","fromOptional","source","select","get","lookup","selected","derive","reactiveDerived","sources","externalReadable","equals","reactiveExternal"],"mappings":"2HA2BA,SAASA,EAAgBC,EAA+B,CACtD,OAAOC,EAAiBD,EAAQ,KAAMA,EAAQ,QAAUE,CAAe,CACzE,CAEA,SAASC,EAAWC,EAAc,CAChC,GAAI,OAAOA,GAAU,UAAYA,IAAU,KAAM,MAAO,GAExD,MAAMC,EAAWD,EAEjB,OAAO,OAAOC,EAAS,aAAgB,YAAc,OAAOA,EAAS,WAAc,UACrF,CAcA,SAASC,EACPC,EACAC,EACAR,EAAmC,CAEnC,OAAOD,EAAS,CACd,GAAIC,EAAQ,SAAW,OAAY,CAAA,EAAK,CAAE,OAAQA,EAAQ,QAC1D,KAAMS,GAAM,CACV,MAAMC,EAASD,EAAIF,CAAM,EAEzB,GAAIG,EAAO,OAAS,UAAW,OAAOV,EAAQ,QAE9C,MAAMW,EAAWH,EAAOE,EAAO,KAAK,EAEpC,OAAOP,EAAWQ,CAAQ,EAAIF,EAAIE,CAAQ,EAAIA,CAChD,CACD,CAAA,CACH,CAMA,SAASC,EACPZ,EAA+F,CAE/F,GAAIG,EAAWH,EAAQ,IAAI,EAAG,CAC5B,MAAMO,EAASP,EAAQ,KACjBQ,EAAUR,EAA0C,OAE1D,OAAOa,EAAgB,CAACN,CAAM,EAAGE,GAAOD,EAAOC,EAAIF,CAAM,CAAC,EAAGP,EAAQ,QAAUE,CAAe,CAChG,CAEA,MAAMY,EAAU,CAAC,GAAGd,EAAQ,IAAI,EAC1BQ,EAAUR,EAAmE,OAEnF,OAAOa,EACLC,EACAL,GAAOD,EAAO,GAAGM,EAAQ,IAAIP,GAAUE,EAAIF,CAAM,CAAC,CAAC,EACnDP,EAAQ,QAAUE,CAAe,CAErC,CAQA,SAASa,EACPR,EACAC,EACAQ,EAAwB,CAExB,OAAOC,EACLV,EACCC,IAAYJ,GAAkBA,GAC9BY,GAAUd,CAAe,CAE9B"}

package/dist/readable.d.ts

@@ -0,0 +1,13 @@
+type ReadableListener = () => void;
+interface Readable<T> {
+    getSnapshot(): T;
+    subscribe(listener: ReadableListener): () => void;
+}
+interface State<T> extends Readable<T> {
+    readonly close: () => void;
+    readonly set: (value: T) => void;
+    readonly update: (update: (current: T) => T) => void;
+}
+declare function createState<T>(initialValue: T): State<T>;
+export { createState };
+export type { Readable, ReadableListener, State };

package/dist/readable.js

@@ -0,0 +1,2 @@
+import{endDataTransaction as f,beginDataTransaction as b}from"./data-scheduler.js";import{ReadableError as d}from"./errors.js";import{createAggregateError as p}from"./platform-compat.js";const h=()=>{},u=Symbol("opetope.closed-readable-state");function m(o){try{return f(),o}catch(e){const r=o??[];return r.push(e),r}}function y(o){let e;for(const{listener:r}of o)try{r()}catch(a){(e??(e=[])).push(a)}return e}function w(o){let e=o,r=!1;const a=new Set,i=()=>{if(r)throw new d("closed","Cannot update a closed readable state.")},c=()=>{if(e===u)throw new d("closed","Cannot read a closed readable state.");return e},l=()=>{if(a.size===0)return;const n=[...a];let t;b();try{t=y(n)}finally{t=m(t)}if(t!==void 0)throw p(t,"Readable listeners failed after the value was committed.")};return Object.freeze({close(){if(!r){r=!0,e=u;try{l()}finally{a.clear()}}},getSnapshot(){return c()},set(n){i(),!Object.is(c(),n)&&(e=n,l())},subscribe(n){if(r)return h;const t={listener:n};a.add(t);let s=!0;return()=>{s&&(s=!1,a.delete(t))}},update(n){i();const t=c(),s=n(t);i(),!Object.is(t,s)&&(e=s,l())}})}export{w as createState};
+//# sourceMappingURL=readable.js.map

package/dist/readable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"readable.js","sources":["../src/readable.ts"],"sourcesContent":["import { beginDataTransaction, endDataTransaction } from './data-scheduler';\nimport { ReadableError } from './errors';\nimport { createAggregateError } from './platform-compat';\n\ntype ReadableListener = () => void;\n\ninterface Readable<T> {\n  getSnapshot(): T;\n  subscribe(listener: ReadableListener): () => void;\n}\n\ninterface State<T> extends Readable<T> {\n  readonly close: () => void;\n  readonly set: (value: T) => void;\n  readonly update: (update: (current: T) => T) => void;\n}\n\nconst noop = (): void => undefined;\nconst closedReadableState = Symbol('opetope.closed-readable-state');\n\ntype ListenerRegistration = { readonly listener: ReadableListener };\n\nfunction endDataTransactionSafely(failures: unknown[] | undefined): unknown[] | undefined {\n  try {\n    endDataTransaction();\n\n    return failures;\n  } catch (error) {\n    const next = failures ?? [];\n    next.push(error);\n\n    return next;\n  }\n}\n\nfunction notifyReadableListeners(listeners: readonly ListenerRegistration[]): unknown[] | undefined {\n  let failures: unknown[] | undefined;\n\n  for (const { listener } of listeners) {\n    try {\n      listener();\n    } catch (error) {\n      (failures ??= []).push(error);\n    }\n  }\n\n  return failures;\n}\n\nfunction createState<T>(initialValue: T): State<T> {\n  let current: typeof closedReadableState | T = initialValue;\n  let closed = false;\n  const listeners = new Set<ListenerRegistration>();\n\n  const assertOpen = (): void => {\n    if (closed) throw new ReadableError('closed', 'Cannot update a closed readable state.');\n  };\n\n  const readCurrent = (): T => {\n    if (current === closedReadableState) {\n      throw new ReadableError('closed', 'Cannot read a closed readable state.');\n    }\n\n    return current;\n  };\n\n  const publish = (): void => {\n    if (listeners.size === 0) return;\n\n    const notified = [...listeners];\n    let failures: unknown[] | undefined;\n\n    beginDataTransaction();\n\n    try {\n      failures = notifyReadableListeners(notified);\n    } finally {\n      failures = endDataTransactionSafely(failures);\n    }\n\n    if (failures !== undefined) {\n      throw createAggregateError(failures, 'Readable listeners failed after the value was committed.');\n    }\n  };\n\n  return Object.freeze({\n    /**\n     * Closing is a change like any other: dependents hear it once, and the read that follows fails instead of\n     * handing out the last value of a source nobody owns any more. A `derive` or `computed` recomputes inside this\n     * transaction, reads a closed source and keeps that failure, so the whole chain answers `closed` (D146).\n     */\n    close(): void {\n      if (closed) return;\n\n      closed = true;\n      current = closedReadableState;\n\n      try {\n        publish();\n      } finally {\n        listeners.clear();\n      }\n    },\n    getSnapshot(): T {\n      return readCurrent();\n    },\n    set(value: T): void {\n      assertOpen();\n\n      if (Object.is(readCurrent(), value)) return;\n\n      current = value;\n      publish();\n    },\n    subscribe(listener: ReadableListener): () => void {\n      if (closed) return noop;\n\n      const registration = { listener };\n      listeners.add(registration);\n      let subscribed = true;\n\n      return (): void => {\n        if (!subscribed) return;\n\n        subscribed = false;\n        listeners.delete(registration);\n      };\n    },\n    update(update: (current: T) => T): void {\n      assertOpen();\n      const previous = readCurrent();\n      const next = update(previous);\n      // D201: the updater is foreign code and may close this state; closing is workspace, so what it computed for the\n      // world before the close never lands.\n      assertOpen();\n\n      if (Object.is(previous, next)) return;\n\n      current = next;\n      publish();\n    },\n  });\n}\n\nexport { createState };\nexport type { Readable, ReadableListener, State };\n"],"names":["noop","closedReadableState","endDataTransactionSafely","failures","endDataTransaction","error","next","notifyReadableListeners","listeners","listener","createState","initialValue","current","closed","assertOpen","ReadableError","readCurrent","publish","notified","beginDataTransaction","createAggregateError","value","registration","subscribed","update","previous"],"mappings":"2LAiBA,MAAMA,EAAO,IAAA,GACPC,EAAsB,OAAO,+BAA+B,EAIlE,SAASC,EAAyBC,EAA+B,CAC/D,GAAI,CACF,OAAAC,EAAkB,EAEXD,CACT,OAASE,EAAO,CACd,MAAMC,EAAOH,GAAY,CAAA,EACzB,OAAAG,EAAK,KAAKD,CAAK,EAERC,CACT,CACF,CAEA,SAASC,EAAwBC,EAA0C,CACzE,IAAIL,EAEJ,SAAW,CAAE,SAAAM,CAAQ,IAAMD,EACzB,GAAI,CACFC,EAAQ,CACV,OAASJ,EAAO,EACbF,MAAa,CAAA,IAAI,KAAKE,CAAK,CAC9B,CAGF,OAAOF,CACT,CAEA,SAASO,EAAeC,EAAe,CACrC,IAAIC,EAA0CD,EAC1CE,EAAS,GACb,MAAML,EAAY,IAAI,IAEhBM,EAAa,IAAW,CAC5B,GAAID,EAAQ,MAAM,IAAIE,EAAc,SAAU,wCAAwC,CACxF,EAEMC,EAAc,IAAQ,CAC1B,GAAIJ,IAAYX,EACd,MAAM,IAAIc,EAAc,SAAU,sCAAsC,EAG1E,OAAOH,CACT,EAEMK,EAAU,IAAW,CACzB,GAAIT,EAAU,OAAS,EAAG,OAE1B,MAAMU,EAAW,CAAC,GAAGV,CAAS,EAC9B,IAAIL,EAEJgB,EAAoB,EAEpB,GAAI,CACFhB,EAAWI,EAAwBW,CAAQ,CAC7C,SACEf,EAAWD,EAAyBC,CAAQ,CAC9C,CAEA,GAAIA,IAAa,OACf,MAAMiB,EAAqBjB,EAAU,0DAA0D,CAEnG,EAEA,OAAO,OAAO,OAAO,CAMnB,OAAK,CACH,GAAI,CAAAU,EAEJ,CAAAA,EAAS,GACTD,EAAUX,EAEV,GAAI,CACFgB,EAAO,CACT,SACET,EAAU,MAAK,CACjB,EACF,EACA,aAAW,CACT,OAAOQ,EAAW,CACpB,EACA,IAAIK,EAAQ,CACVP,EAAU,EAEN,QAAO,GAAGE,EAAW,EAAIK,CAAK,IAElCT,EAAUS,EACVJ,EAAO,EACT,EACA,UAAUR,EAA0B,CAClC,GAAII,EAAQ,OAAOb,EAEnB,MAAMsB,EAAe,CAAE,SAAAb,CAAQ,EAC/BD,EAAU,IAAIc,CAAY,EAC1B,IAAIC,EAAa,GAEjB,MAAO,IAAW,CACXA,IAELA,EAAa,GACbf,EAAU,OAAOc,CAAY,EAC/B,CACF,EACA,OAAOE,EAAyB,CAC9BV,EAAU,EACV,MAAMW,EAAWT,EAAW,EACtBV,EAAOkB,EAAOC,CAAQ,EAG5BX,EAAU,EAEN,QAAO,GAAGW,EAAUnB,CAAI,IAE5BM,EAAUN,EACVW,EAAO,EACT,CACD,CAAA,CACH"}

package/dist/resource.d.ts

@@ -0,0 +1,82 @@
+import type { Readable } from './readable.js';
+/**
+ * The async materialization contract. It lives in `core` because `ModelContext.resource` and `ModelContext.stream`
+ * name it (D73); `runtime` owns the controllers and the retention policies and re-exports these types unchanged.
+ */
+type ResourceRequestKey = number | string;
+type ResourceIdleSnapshot = {
+    readonly attempt: 0;
+    readonly data: undefined;
+    readonly error: undefined;
+    readonly generation: number;
+    readonly key: null;
+    readonly stale: false;
+    readonly status: 'idle';
+};
+type ResourceOpeningSnapshot<Data, Key extends ResourceRequestKey> = {
+    readonly attempt: number;
+    readonly data: Data | undefined;
+    readonly error: undefined;
+    readonly generation: number;
+    readonly key: Key;
+    readonly stale: boolean;
+    readonly status: 'opening';
+};
+type ResourceReadySnapshot<Data, Key extends ResourceRequestKey> = {
+    readonly attempt: number;
+    readonly data: Data;
+    readonly error: undefined;
+    readonly generation: number;
+    readonly key: Key;
+    readonly stale: false;
+    readonly status: 'ready';
+};
+type ResourceRefreshingSnapshot<Data, Key extends ResourceRequestKey> = {
+    readonly attempt: number;
+    readonly data: Data;
+    readonly error: undefined;
+    readonly generation: number;
+    readonly key: Key;
+    readonly stale: true;
+    readonly status: 'refreshing';
+};
+type ResourceErrorSnapshot<Data, Key extends ResourceRequestKey> = {
+    readonly attempt: number;
+    readonly data: Data | undefined;
+    readonly error: unknown;
+    readonly generation: number;
+    readonly key: Key;
+    readonly retryable: true;
+    readonly stale: boolean;
+    readonly status: 'error';
+};
+type ResourceSnapshot<Data, Key extends ResourceRequestKey = ResourceRequestKey> = ResourceErrorSnapshot<Data, Key> | ResourceIdleSnapshot | ResourceOpeningSnapshot<Data, Key> | ResourceReadySnapshot<Data, Key> | ResourceRefreshingSnapshot<Data, Key>;
+interface Resource<Data, Key extends ResourceRequestKey = ResourceRequestKey> extends Readable<ResourceSnapshot<Data, Key>> {
+    readonly invalidate: () => void;
+    readonly refresh: () => void;
+    readonly retain: () => () => void;
+    readonly retry: () => void;
+}
+/**
+ * The default retention: a resource lives while somebody observes it, releases after a microtask grace and aborts
+ * what is still in flight. Both fields admitted exactly one value each, so the record collapsed to its kind (D160).
+ */
+type ObserverRetention = {
+    readonly kind: 'observer';
+};
+type ScopedRetention = {
+    readonly capacity: number;
+    readonly evict: 'lru';
+    readonly kind: 'scope';
+};
+type ResourceRetention = ObserverRetention | ScopedRetention;
+type ResourceRetry = {
+    readonly attempts: number;
+    readonly delayMs: number;
+};
+type LatestBackpressure = {
+    readonly kind: 'latest';
+};
+/** §3 publishes one policy, so the union has one member: `drop`, `sample` and `queue` were unreachable (D160). */
+type StreamBackpressure = LatestBackpressure;
+export type { LatestBackpressure, ObserverRetention, Resource, ResourceRequestKey, ResourceRetention, ResourceRetry, ResourceSnapshot, ScopedRetention, StreamBackpressure, };

package/dist/type-helpers.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Type facts every layer needs, declared once. They were re-declared per file — `Awaitable` in nineteen, the
+ * exact-input trio in a dozen — and every copy is a second place where the same rule can drift (D150).
+ */
+type Awaitable<Value> = PromiseLike<Value> | Value;
+type IsAny<Value> = 0 extends 1 & Value ? true : false;
+type ExactType<Left, Right> = [Left] extends [Right] ? ([Right] extends [Left] ? true : false) : false;
+/** Author options are exact: an extra key is `never`, so a typo fails where it is written. */
+type NoExtraKeys<Actual, Expected> = Record<Exclude<keyof Actual, keyof Expected>, never>;
+type ExactInput<Actual, Shape> = Actual & NoExtraKeys<Actual, Shape> & Shape;
+type ExactKeys<Keys extends PropertyKey, Shape> = Record<Exclude<Keys, keyof Shape>, never> & Record<Keys, unknown>;
+/** A lifecycle callback publishes nothing: `void` or a promise of it, and `any` is not a way around that. */
+type ExactVoidResult<Value> = IsAny<Value> extends true ? never : [Value] extends [Awaitable<void>] ? unknown : never;
+export type { Awaitable, ExactInput, ExactKeys, ExactType, ExactVoidResult, IsAny, NoExtraKeys };

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@opetope/core",
+  "version": "0.1.0",
+  "engines": {
+    "node": ">=20.19.0"
+  },
+  "browserslist": [
+    "Chrome >= 82",
+    "Firefox >= 110",
+    "Safari >= 15",
+    "iOS >= 15",
+    "Android >= 82"
+  ],
+  "type": "module",
+  "files": [
+    "dist",
+    "README.md",
+    "README.ru.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./internal": {
+      "types": "./dist/internal.d.ts",
+      "import": "./dist/internal.js"
+    }
+  },
+  "scripts": {
+    "build": "rollup --config rollup.config.cjs",
+    "build:size-consumers": "rollup --config rollup.size.config.cjs",
+    "ci:eslint": "eslint src --quiet",
+    "ci:size-limit": "node ../../tooling/typecheck.mjs --noEmit -p tsconfig.size.json && npm run build:size-consumers && size-limit",
+    "ci:type": "node ../../tooling/typecheck.mjs --noEmit && node ../../tooling/typecheck.mjs --noEmit -p tsconfig.size.json",
+    "ci:test": "node --expose-gc --experimental-vm-modules ../../node_modules/jest/bin/jest.js"
+  },
+  "size-limit": [
+    {
+      "name": "author primitives consumer",
+      "path": "../../node_modules/.cache/opetope-core-size/author.js",
+      "limit": "1.1kb"
+    },
+    {
+      "name": "data layer consumer",
+      "path": "../../node_modules/.cache/opetope-core-size/data.js",
+      "limit": "4.9kb"
+    }
+  ],
+  "sideEffects": false,
+  "description": "Typed reactive primitives and command execution for Opetope.",
+  "license": "MIT",
+  "author": "Aleksei Berezin",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/telchardev/opetope.git",
+    "directory": "packages/core"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}