@githolon/dsl 0.108.1 → 0.108.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@githolon/dsl",
-  "version": "0.108.1",
+  "version": "0.108.2",
   "type": "module",
   "sideEffects": false,
   "description": "Nomos 2 domain-authoring DSL: aggregates + directives in TS, executed and encoded to the Rust kernel's wire shapes.",

package/src/framework/relations.ts

@@ -211,10 +211,20 @@ export const RelationshipSubjectValue = valueObject("RelationshipSubject", {
   ownedCustody: OwnedCustodyValue.optional(),
 });
 
+// Historical RelationTuple law declared this map value as `t.json()`, but the
+// kernel has always admitted and stored only the nominal RelationshipSubject
+// palette for this framework field. Keep that exact prior declaration as the
+// source of the explicit evolution edge: this is a type-disclosure refinement
+// of existing structured custody, not a JSON parser or a business-data cast.
+const LegacyRelationshipSubjects = t.map(t.json()).merge(MapOf(Lww));
+
 export const RelationTuple = aggregate("RelationTuple", {
   object: t.string().merge(Lww),
   relation: t.string().merge(Lww),
-  subjects: t.map(RelationshipSubjectValue.field()).merge(MapOf(Lww)),
+  subjects: t
+    .map(RelationshipSubjectValue.field())
+    .merge(MapOf(Lww))
+    .evolvesFrom(LegacyRelationshipSubjects),
 }).public();
 export type RelationTupleHandle = typeof RelationTuple;
 

package/src/stable_ids_for_module.ts

@@ -50,7 +50,16 @@ export function stableIdsForModule(mod: DomainModule): StableIds {
       const evolutions =
         handle === undefined || schema === undefined || driver === undefined || details === undefined
           ? []
-          : fieldEvolutionRules(handle, pf, aggSid, pf?.sid ?? mintFieldSid(aggSid, fieldName), details, driver, schema);
+          : fieldEvolutionRules(
+              handle,
+              pf,
+              aggSid,
+              pf?.sid ?? mintFieldSid(aggSid, fieldName),
+              details,
+              driver,
+              schema,
+              { aggregateId: agg.id, fieldName },
+            );
       fields[fieldName] = {
         sid: pf?.sid ?? mintFieldSid(aggSid, fieldName),
         ...(pf?.was !== undefined && pf.was.length > 0 ? { was: pf.was } : {}),
@@ -147,6 +156,7 @@ function fieldEvolutionRules(
   target: { contract: string; shape: unknown },
   driver: unknown,
   targetSchema: string,
+  identity: { aggregateId: string; fieldName: string },
 ): StableFieldEvolution[] {
   const bySource = new Map<string, StableFieldEvolution>();
   const add = (rule: StableFieldEvolution, origin: string) => {
@@ -172,7 +182,10 @@ function fieldEvolutionRules(
       source.contract,
       encodeDriver(declaration.source.driver),
     );
-    if (declaration.mode === "identity" && !safeIdentityProjection(source.shape, target.shape)) {
+    if (
+      declaration.mode === "identity" &&
+      !safeIdentityProjection(source.shape, target.shape, identity)
+    ) {
       throw new Error(
         `.evolvesFrom(source) is not a safe identity widening: some source values are not valid ` +
           `under the target field. Supply a finite business transform as the second argument.`,
@@ -247,12 +260,30 @@ function fieldEvolutionRules(
 
 /** Explicit identity projection: the tenant declares the business meaning is continuous;
  * the compiler still proves every old value is accepted and its physical decoding is unchanged. */
-function safeIdentityProjection(sourceShape: unknown, targetShape: unknown): boolean {
+function safeIdentityProjection(
+  sourceShape: unknown,
+  targetShape: unknown,
+  identity?: { aggregateId: string; fieldName: string },
+): boolean {
   if (sourceShape === null || targetShape === null || typeof sourceShape !== "object" || typeof targetShape !== "object") {
     return canonicalJson(sourceShape) === canonicalJson(targetShape);
   }
   const source = sourceShape as Record<string, unknown>;
   const target = targetShape as Record<string, unknown>;
+  // RelationTuple.subjects is a kernel-native framework palette, not a tenant
+  // JSON field. Historical DSL metadata called its map leaf `json`, while the
+  // kernel already admitted/stored only RelationshipSubject values. The typed
+  // value-object declaration therefore discloses the existing contract without
+  // changing physical decoding or widening what old writers can author. Keep
+  // this proof bound to the one kernel-special field; arbitrary JSON->VO
+  // narrowing remains refused below.
+  if (
+    identity?.aggregateId === "RelationTuple" &&
+    identity.fieldName === "subjects" &&
+    isRelationshipSubjectDisclosure(source, target)
+  ) {
+    return true;
+  }
   const physical = (shape: Record<string, unknown>) => {
     const { kind, mapValueKind, jsonShape, encrypted } = shape;
     // `t.ref` and `t.foreignRef` store the target aggregate id as the same Str
@@ -267,6 +298,21 @@ function safeIdentityProjection(sourceShape: unknown, targetShape: unknown): boo
     && jsonSchemaSubset(source.jsonSchema, target.jsonSchema);
 }
 
+function isRelationshipSubjectDisclosure(
+  source: Record<string, unknown>,
+  target: Record<string, unknown>,
+): boolean {
+  const targetVo = target.mapValueVo as
+    | { descriptor?: { name?: unknown } }
+    | undefined;
+  return source.kind === "map" &&
+    target.kind === "map" &&
+    source.mapValueKind === "json" &&
+    target.mapValueKind === "json" &&
+    source.mapValueVo === undefined &&
+    targetVo?.descriptor?.name === "RelationshipSubject";
+}
+
 /** Automatic widening is stricter: every non-schema business descriptor must remain
  * identical. Brands, units, references and null meaning require an explicit declaration. */
 function safeAutomaticWidening(sourceShape: unknown, targetShape: unknown): boolean {
@@ -310,7 +356,21 @@ function jsonSchemaSubset(source: unknown, target: unknown): boolean {
         return false;
       }
     }
-    if (s.additionalProperties !== false && t.additionalProperties === false) return false;
+    const sourceAdditional = s.additionalProperties;
+    const targetAdditional = t.additionalProperties;
+    if (sourceAdditional !== false) {
+      if (targetAdditional === false) return false;
+      if (targetAdditional !== undefined && targetAdditional !== true) {
+        if (
+          sourceAdditional === undefined ||
+          sourceAdditional === true ||
+          typeof sourceAdditional !== "object" ||
+          !jsonSchemaSubset(sourceAdditional, targetAdditional)
+        ) {
+          return false;
+        }
+      }
+    }
   }
   if (sourceTypes.has("array") && s.items !== undefined && t.items !== undefined) {
     if (!jsonSchemaSubset(s.items, t.items)) return false;