effect-app 4.0.0-beta.304 → 4.0.0-beta.306

package/dist/rpc/Invalidation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Invalidation.d.ts","sourceRoot":"","sources":["../../src/rpc/Invalidation.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"Invalidation.d.ts","sourceRoot":"","sources":["../../src/rpc/Invalidation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,YAAY,CAAA;AACjC,OAAO,EAAE,GAAG,EAAE,MAAM,qBAAqB,CAAA;AACzC,OAAO,EAAE,KAAK,gBAAgB,EAAgB,MAAM,wBAAwB,CAAA;AAC5E,OAAO,KAAK,OAAO,MAAM,eAAe,CAAA;AACxC,OAAO,KAAK,gBAAgB,MAAM,wBAAwB,CAAA;AAC1D,OAAO,KAAK,MAAM,MAAM,cAAc,CAAA;AACtC,OAAO,KAAK,CAAC,MAAM,cAAc,CAAA;AAEjC;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAAG,eAAe,GAAG;IAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,gBAAgB,CAAA;CAAE,CAAA;AAmBjH;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,uCAAS,CAAA;AAC5C,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAEjF,6GAA6G;AAC7G,eAAO,MAAM,eAAe;;;CAAkC,CAAA;AAC9D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,eAAe,CAAC,CAAA;AAEnE,oFAAoF;AACpF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;CAA2B,CAAA;AACxD,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAErE,wFAAwF;AACxF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG1B,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,eAAe,CAAC,CAAA;AAEnE,eAAO,MAAM,qBAAqB,EAAE,gBAAgB,CAAC,iBAGpD,CAAA;AAED,eAAO,MAAM,YAAY,sBACJ,gBAAgB,qBACjB,gBAAgB,CAAC,iBAAiB,KACnD,eAA4D,CAAA;AAE/D,eAAO,MAAM,yBAAyB,GAAI,CAAC,SAAS,CAAC,CAAC,GAAG,WAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACyC,CAAA;AAE9G;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,GAAI,CAAC,SAAS,CAAC,CAAC,GAAG,WAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACZ,CAAA;AAE3D;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,GAAI,CAAC,SAAS,CAAC,CAAC,GAAG,SAAS,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAC2B,CAAA;AAE/F;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,GAAI,CAAC,SAAS,CAAC,CAAC,GAAG,WAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAK3D,CAAA;AAEJ,MAAM,MAAM,mBAAmB,CAAC,CAAC,IAC7B;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAC7C;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAA;CAAE,GACjE;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAA;CAAE,CAAA;AAEjE;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,GAAI,CAAC,SAAS,CAAC,CAAC,GAAG,SAAS,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACc,CAAA;AAE1E,MAAM,MAAM,kBAAkB,CAAC,CAAC,IAAI;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAA;CAAE,CAAA;AAErH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,WAAW,mDAGvB,CAAA;AACD,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAA;AAE5C,+EAA+E;AAC/E,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,GAAG,EAAE,CACZ,KAAK,EAAE,oBAAoB,GAAG,aAAa,CAAC,oBAAoB,CAAC,KAC9D,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IACxB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,eAAe,CAAC,CAAC,CAAA;IAC3D;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,eAAe,CAAC,CAAC,CAAA;CAC9D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,QAAA,MAAM,kBAAkB,2CASvB,CAAA;AACD,eAAO,MAAM,eAAe;IAC1B;;;OAGG;iBACU,oBAAoB,GAAG,aAAa,CAAC,oBAAoB,CAAC;CAEvE,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,OAAO,kBAAkB,CAAA;AAEvD,0EAA0E;AAC1E,eAAO,MAAM,mBAAmB,QAAS,GAAG,CAAC,GAAG,CAAC,aAAa,CAAC,eAAe,CAAC,CAAC,KAAG,sBAIjF,CAAA;AAEF;;;;;;;;GAQG;AAEH,MAAM,WAAW,UAAW,SAAQ,GAAG,CAAC,MAAM;IAC5C,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,CAC1B,UAAU,CAAC,OAAO,2BAA2B,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,EACvE,UAAU,CAAC,OAAO,0BAA0B,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CACrE,CAAA;CACF;AAED;;;;GAIG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0TAIxB,CAAA;AAEH;;;GAGG;AAEH,MAAM,WAAW,SAAU,SAAQ,GAAG,CAAC,MAAM;IAC3C,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,CAC1B,UAAU,CAAC,OAAO,mBAAmB,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,EAC/D,UAAU,CAAC,OAAO,kBAAkB,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAC7D,CAAA;CACF;AAED;;;;GAIG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0TAIvB,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-app",
-  "version": "4.0.0-beta.304",
+  "version": "4.0.0-beta.306",
   "license": "MIT",
   "type": "module",
   "repository": {

package/src/DataDependencies.ts

@@ -14,7 +14,8 @@ export const DataDependency = S.Union([
   }),
   S.Struct({
     type: S.Literal("signal"),
-    name: S.String
+    name: S.String,
+    ids: S.optional(S.NonEmptyArray(S.String))
   })
 ])
 export type DataDependency = S.Schema.Type<typeof DataDependency>
@@ -42,7 +43,6 @@ const sameDomain = (a: DataDependency, b: DataDependency) => a.type === b.type &
 
 const dependenciesOverlap = (a: DataDependency, b: DataDependency) => {
   if (!sameDomain(a, b)) return false
-  if (a.type === "signal" || b.type === "signal") return true
   if (a.ids === undefined || b.ids === undefined) return true
   return a.ids.some((id) => b.ids?.includes(id))
 }
@@ -57,7 +57,6 @@ const containsDependency = (dependencies: ReadonlySet<DataDependency>, dependenc
 const appendDependency = (dependency: DataDependency) => (dependencies: DataDependencies): DataDependencies => {
   const existing = [...dependencies].find((_) => sameDomain(_, dependency))
   if (existing === undefined) return new Set([...dependencies, dependency])
-  if (existing.type === "signal" || dependency.type === "signal") return dependencies
   if (existing.ids === undefined) return dependencies
   if (dependency.ids === undefined) {
     return new Set([...dependencies].filter((_) => _ !== existing).concat(dependency))
@@ -68,10 +67,18 @@ const appendDependency = (dependency: DataDependency) => (dependencies: DataDepe
     ...new Set([...existing.ids.slice(1), ...dependency.ids].filter((id) => id !== first))
   ]
   if (ids.length === existing.ids.length) return dependencies
-  const merged = repo(existing.name, ids)
+  const merged = existing.type === "repo" ? repo(existing.name, ids) : signal(existing.name, ids)
   return new Set([...dependencies].filter((_) => _ !== existing).concat(merged))
 }
 
+export const merge = (...groups: ReadonlyArray<DataDependencies>): DataDependencies => {
+  let merged = empty()
+  for (const group of groups) {
+    for (const dependency of group) merged = appendDependency(dependency)(merged)
+  }
+  return merged
+}
+
 export const DataDependencyRecorder = RequestScopedDependencies.make(
   "effect-app/DataDependencyRecorder",
   Effect.gen(function*() {
@@ -125,7 +132,8 @@ export const makeDataDependencyRecorder = (
 
 export const repo = (name: string, ids?: NonEmptyReadonlyArray<string>): DataDependency =>
   ids === undefined ? { type: "repo", name } : { type: "repo", name, ids }
-export const signal = (name: string): DataDependency => ({ type: "signal", name })
+export const signal = (name: string, ids?: NonEmptyReadonlyArray<string>): DataDependency =>
+  ids === undefined ? { type: "signal", name } : { type: "signal", name, ids }
 
 const RepoReadScope = Context.Reference<DataDependency | undefined>("effect-app/DataDependencies/RepoReadScope", {
   defaultValue: () => undefined

package/src/Model/Repository/internal/internal.ts

@@ -115,6 +115,7 @@ export function makeRepoInternal<
           schemaContext?: Context.Context<RCtx>
           makeInitial?: Effect.Effect<readonly T[], E, RInitial> | undefined
           dependencyIds?: (item: T) => NonEmptyReadonlyArray<string>
+          additionalWriteDependencies?: (item: T) => ReadonlyArray<DataDependencies.DataDependency>
           config?: Omit<StoreConfig<Encoded>, "partitionValue"> & {
             partitionValue?: (e?: Encoded) => string
           }
@@ -124,6 +125,7 @@ export function makeRepoInternal<
           publishEvents: (evt: NonEmptyReadonlyArray<Evt>) => Effect.Effect<void, never, RPublish>
           makeInitial?: Effect.Effect<readonly T[], E, RInitial> | undefined
           dependencyIds?: (item: T) => NonEmptyReadonlyArray<string>
+          additionalWriteDependencies?: (item: T) => ReadonlyArray<DataDependencies.DataDependency>
           config?: Omit<StoreConfig<Encoded>, "partitionValue"> & {
             partitionValue?: (e?: Encoded) => string
           }
@@ -148,18 +150,28 @@ export function makeRepoInternal<
           const recordRead = DataDependencies.readRepo(name)
           const entityDependency = (ids: NonEmptyReadonlyArray<T[IdKey]>) =>
             DataDependencies.repo(name, [String(ids[0]), ...ids.slice(1).map(String)])
-          const itemDependency = (items: NonEmptyReadonlyArray<T>) => {
-            const firstIds = args.dependencyIds?.(items[0]) ?? [String(items[0][idKey])]
-            return DataDependencies.repo(name, [
-              firstIds[0],
-              ...firstIds.slice(1),
-              ...items.slice(1).flatMap((item) => args.dependencyIds?.(item) ?? [String(item[idKey])])
-            ])
+          const itemDependencies = (item: T) => {
+            const ids = args.dependencyIds?.(item) ?? [String(item[idKey])]
+            return [
+              DataDependencies.repo(name, ids),
+              ...(args.additionalWriteDependencies?.(item) ?? [])
+            ]
           }
           const recordEntityRead = (id: T[IdKey]) => DataDependencies.read(entityDependency([id]))
           const recordEntityWrite = (ids: NonEmptyReadonlyArray<T[IdKey]>) =>
             DataDependencies.write(entityDependency(ids))
-          const recordItemWrite = (items: NonEmptyReadonlyArray<T>) => DataDependencies.write(itemDependency(items))
+          const recordItemWrite = (items: NonEmptyReadonlyArray<T>) =>
+            Effect.forEach(
+              DataDependencies.merge(new Set(items.flatMap(itemDependencies))),
+              DataDependencies.write,
+              { discard: true }
+            )
+          const recordAdditionalItemWrites = (items: ReadonlyArray<T>) =>
+            Effect.forEach(
+              DataDependencies.merge(new Set(items.flatMap((item) => args.additionalWriteDependencies?.(item) ?? []))),
+              DataDependencies.write,
+              { discard: true }
+            )
           const cms = Effect.map(getContextMap.pipe(Effect.orDie), (_) => ({
             get: (id: string) => _.get(`${name}.${id}`),
             set: (id: string, etag: string | undefined) => _.set(`${name}.${id}`, etag)
@@ -292,6 +304,20 @@ export function makeRepoInternal<
             )
           })
 
+          const loadExistingItems = (ids: ReadonlyArray<T[IdKey]>) =>
+            Effect
+              .forEach(
+                ids,
+                (id) =>
+                  findE(id).pipe(
+                    Effect.flatMap(Option.match({
+                      onNone: () => Effect.succeed(Option.none<T>()),
+                      onSome: (encoded) => decode(encoded).pipe(Effect.orDie, Effect.map(Option.some))
+                    }))
+                  )
+              )
+              .pipe(Effect.map(Array.getSomes))
+
           const find = Effect.fn("Repository.find", {
             kind: "client",
             attributes: { "app.entity": name }
@@ -327,7 +353,10 @@ export function makeRepoInternal<
               const it = Chunk.fromIterable(items)
               if (Chunk.isNonEmpty(it)) {
                 const values = Chunk.toReadonlyArray(it)
-                yield* recordItemWrite([values[0], ...values.slice(1)])
+                const previous = args.additionalWriteDependencies
+                  ? yield* loadExistingItems(values.map((item) => item[idKey]))
+                  : []
+                yield* recordItemWrite([values[0], ...values.slice(1), ...previous])
               }
               const evts = [...events]
               yield* Effect.annotateCurrentSpan({
@@ -385,6 +414,9 @@ export function makeRepoInternal<
                 return
               }
               yield* recordEntityWrite(ids)
+              if (args.additionalWriteDependencies) {
+                yield* loadExistingItems(ids).pipe(Effect.flatMap(recordAdditionalItemWrites))
+              }
               const { set } = yield* cms
               const eids = yield* Effect.forEach(ids, (_) => encodeIdOnly(_ as any)).pipe(Effect.orDie)
               yield* Effect.annotateCurrentSpan({ "app.entity.ids": eids })

package/src/Model/Repository/makeRepo.ts

@@ -9,6 +9,7 @@
 import type * as Scope from "effect/Scope"
 import type { NonEmptyReadonlyArray } from "../../Array.ts"
 import type * as Context from "../../Context.ts"
+import type * as DataDependencies from "../../DataDependencies.ts"
 import * as Effect from "../../Effect.ts"
 import type * as S from "../../Schema.ts"
 import type { StoreConfig, StoreMaker } from "../../Store.ts"
@@ -61,6 +62,13 @@ export interface RepositoryOptions<
   /** IDs, including aliases, that identify an entity for dependency invalidation. */
   dependencyIds?: (item: T) => NonEmptyReadonlyArray<string>
 
+  /**
+   * Additional derived queries or resources affected by writing an item.
+   * Saves invalidate dependencies derived from both the previous and next item;
+   * removals derive them from the removed item.
+   */
+  additionalWriteDependencies?: (item: T) => ReadonlyArray<DataDependencies.DataDependency>
+
   overrides?: (
     repo: Repository<T, Encoded, Evt, ItemType, IdKey, Exclude<RSchema, RCtx>, RPublish, RCtx>
   ) => Repository<T, Encoded, Evt, ItemType, IdKey, Exclude<RSchema, RCtx>, RPublish, RCtx>

package/src/Model/query/dsl.ts

@@ -62,19 +62,96 @@ type LiteralValue<T> = T extends { readonly literal: infer L } ? L : T
 type ExtractTagged<From, Tag> = From extends { readonly _tag: infer FromTag }
   ? [LiteralValue<FromTag>] extends [LiteralValue<Tag>] ? From : never
   : never
-type ProjectableSource<I, From> = I extends { readonly _tag: infer Tag } ? ExtractTagged<From, Tag>
+/**
+ * Domain shape that may supply stored fields for projection member `I`.
+ *
+ * - True tagged unions (`A | B` with different fields per `_tag`) resolve to the
+ *   matching member so state-owned keys are not treated as universal.
+ * - Flat models that only carry `_tag: "a" | "b"` on a shared shape (no
+ *   per-tag members in the Encoded union) fall back to the full `From` so
+ *   existing Class+Literals projections keep typechecking.
+ */
+type ProjectableSource<I, From> = I extends { readonly _tag: infer Tag } ? (
+    [ExtractTagged<From, Tag>] extends [never] ? From : ExtractTagged<From, Tag>
+  )
   : From
-type ProjectableField<I, From, K extends PropertyKey> = K extends KeysOfUnion<From> ? I
-  : never
-type ProjectableEncoded<I, From> = I extends FieldValues ? {
-    [K in keyof I]: ProjectableField<
-      I[K],
-      ProjectableSource<I, From>,
-      K
-    >
+
+/**
+ * One projection member is projectable when every key is either:
+ * - in `ExtraKeys` (computed by the query / not stored on the domain row), or
+ * - a key of the matching domain source member (key presence only; nested
+ *   field types may be narrowed by the projection).
+ *
+ * Uses `keyof Source` (not `KeysOfUnion` of the whole domain union) so a field
+ * owned only by some tags cannot be required on every branch.
+ */
+/**
+ * Keys the domain may supply for projection member `I`.
+ * - Tagged `I`: only keys of the matching domain state.
+ * - Untagged `I` (plain project DTOs): keys present on *any* domain member
+ *   (`KeysOfUnion`), matching historical `project()` behavior.
+ */
+type ProjectableDomainKeys<I, From> = I extends { readonly _tag: any } ? keyof ProjectableSource<I, From>
+  : KeysOfUnion<From>
+
+type ProjectableEncodedMember<
+  I,
+  From,
+  ExtraKeys extends PropertyKey = never
+> = I extends FieldValues ? {
+    // Keep `I[K]` (key presence only). Requiring domain field types would reject
+    // legitimate projections that narrow nested shapes (e.g. package views).
+    [K in keyof I]-?: K extends ExtraKeys ? I[K]
+      : K extends ProjectableDomainKeys<I, From> ? I[K]
+      : never
   }
   : never
-type ProjectableGuard<I, From> = [I] extends [ProjectableEncoded<I, From>] ? unknown : never
+
+/**
+ * Distribute over tagged-union projection Encoded types. A non-distributive
+ * `[I] extends [...]` check against a union only sees `keyof (A|B)` (key
+ * intersection) and misses branch-only fields like cancel-only omissions.
+ */
+type IsProjectableMember<I, From, ExtraKeys extends PropertyKey> = [I] extends
+  [ProjectableEncodedMember<I, From, ExtraKeys>] ? true : false
+
+/**
+ * `unknown` when every member of projection Encoded `I` is projectable from
+ * domain Encoded `From` (plus optional ExtraKeys for computed fields); `never`
+ * otherwise — use as an intersection constraint on a schema argument.
+ */
+type ProjectableGuard<I, From, ExtraKeys extends PropertyKey = never> = false extends (
+  I extends any ? IsProjectableMember<I, From, ExtraKeys> : never
+) ? never
+  : unknown
+
+/**
+ * Compile-time proof that a projection Encoded shape only requires stored keys
+ * that exist on the matching domain tagged state (or non-tagged source), plus
+ * any `ExtraKeys` filled by `projectComputed` (counts, flags, collects, …).
+ *
+ * Catches the class of Overview.List SchemaError where a cancel/recovery state
+ * omits a workflow lock field (`activeRequest`) in the domain model but the
+ * projection still requires it on every branch.
+ *
+ * @example
+ * ```ts
+ * type _ok = ProjectableFromDomain<
+ *   { readonly _tag: "cancelled"; readonly id: string },
+ *   DomainEnc
+ * > // unknown
+ *
+ * type _bad = ProjectableFromDomain<
+ *   { readonly _tag: "cancelled"; readonly id: string; readonly activeRequest: null },
+ *   DomainEnc
+ * > // never — activeRequest is not on domain cancelled
+ * ```
+ */
+export type ProjectableFromDomain<
+  ProjectionEncoded,
+  DomainEncoded,
+  ExtraKeys extends PropertyKey = never
+> = ProjectableGuard<ProjectionEncoded, DomainEncoded, ExtraKeys>
 
 export type RelationDirection = "some" | "every"
 export type Relation = { relation: RelationDirection }
@@ -839,6 +916,33 @@ const makeComputedHelpers = <TFieldValues extends FieldValues>(): ComputedHelper
   relation: (path) => relation<TFieldValues, typeof path>(path)
 })
 
+/**
+ * Only treat computed-map keys as ExtraKeys when `M` is a concrete object type.
+ * `ComputedProjectionMap` is `Record<string, …>`, so `keyof M` is `string` and
+ * would otherwise allow every projection field as "computed".
+ */
+type ConcreteComputedKeys<M> = string extends keyof M ? never : Extract<keyof M, PropertyKey>
+
+/**
+ * Proof that projection Encoded `I` is projectable from domain Encoded, allowing
+ * concrete computed keys. Intersected onto the computed-map argument so
+ * inference of `M` is complete before the check runs.
+ */
+type ProjectableComputedMap<
+  M extends ComputedProjectionMap,
+  I extends FieldValues,
+  Domain
+> =
+  & M
+  & NoExtraComputedKeys<M, I>
+  & (
+    [ProjectableGuard<I, Domain, ConcreteComputedKeys<M>>] extends [never] ? {
+        readonly __projectableFromDomain:
+          "projection fields must exist on the matching domain tagged state or be computed keys"
+      }
+      : unknown
+  )
+
 export const projectComputed: {
   <
     Q extends Query<any> | QueryWhere<any, any, any> | QueryEnd<any, "one" | "many", any>,
@@ -848,7 +952,7 @@ export const projectComputed: {
     E extends boolean = ExtractExclusiveness<Q>
   >(
     schema: Schema,
-    build: (helpers: ComputedHelpers<ExtractFieldValues<Q>>) => M & NoExtraComputedKeys<M, I>,
+    build: (helpers: ComputedHelpers<ExtractFieldValues<Q>>) => ProjectableComputedMap<M, I, ExtractFieldValues<Q>>,
     mode: "collect"
   ): (
     current: Q
@@ -868,7 +972,7 @@ export const projectComputed: {
     E extends boolean = ExtractExclusiveness<Q>
   >(
     schema: Schema,
-    build: (helpers: ComputedHelpers<ExtractFieldValues<Q>>) => M & NoExtraComputedKeys<M, I>,
+    build: (helpers: ComputedHelpers<ExtractFieldValues<Q>>) => ProjectableComputedMap<M, I, ExtractFieldValues<Q>>,
     mode?: "project"
   ): (
     current: Q
@@ -882,7 +986,7 @@ export const projectComputed: {
     E extends boolean = ExtractExclusiveness<Q>
   >(
     schema: Schema,
-    computedProjection: M & NoExtraComputedKeys<M, I>,
+    computedProjection: ProjectableComputedMap<M, I, ExtractFieldValues<Q>>,
     mode: "collect"
   ): (
     current: Q
@@ -902,7 +1006,7 @@ export const projectComputed: {
     E extends boolean = ExtractExclusiveness<Q>
   >(
     schema: Schema,
-    computedProjection: M & NoExtraComputedKeys<M, I>,
+    computedProjection: ProjectableComputedMap<M, I, ExtractFieldValues<Q>>,
     mode?: "project"
   ): (
     current: Q