@reventlessdev/trait-attachments 1.0.0-alpha.1 → 1.0.0-alpha.11

package/src/Attachments_Scaffold.res.mjs

@@ -3,15 +3,18 @@
 import * as Sury from "sury";
 import * as Belt_Array from "@rescript/runtime/lib/es6/Belt_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Attachments_Rules$TraitAttachments from "./Attachments_Rules.res.mjs";
 
 let configSchema = Sury.$schema(s => ({
   entity: s.m(Sury.string),
   entityId: s.m(Sury.string),
   noun: s.m(Sury.string),
   file: s.m(Sury.string),
+  cardinality: s.m(Sury.$option(Attachments_Rules$TraitAttachments.cardinalitySchema)),
   created: s.m(Sury.string),
   createdCarriesEntityId: s.m(Sury.$option(Sury.bool)),
   view: s.m(Sury.string),
+  lifecycleType: s.m(Sury.$option(Sury.string)),
   refType: s.m(Sury.$option(Sury.string)),
   authorize: s.m(Sury.$option(Sury.string)),
   transition: s.m(Sury.$option(Sury.array(Sury.string))),
@@ -19,17 +22,28 @@ let configSchema = Sury.$schema(s => ({
   refB: s.m(Sury.$option(Sury.string))
 }));
 
+function cardinalityOf(c) {
+  return Stdlib_Option.getOr(c.cardinality, "Many");
+}
+
+function isSingle(c) {
+  return Stdlib_Option.getOr(c.cardinality, "Many") === "Single";
+}
+
 function namesOf(c) {
   let subject = c.entity + c.noun;
   return {
     slice: subject + "s",
-    attachCmd: "Attach" + subject,
+    attachCmd: (
+      Stdlib_Option.getOr(c.cardinality, "Many") === "Single" ? "Set" : "Attach"
+    ) + subject,
     removeCmd: "Remove" + subject,
     setPrimaryCmd: "SetPrimary" + subject,
     setAltTextCmd: "Set" + subject + "AltText",
     attached: subject + "Attached",
     removed: subject + "Removed",
     primarySet: c.entity + "Primary" + c.noun + "Set",
+    effectiveChanged: c.entity + "Effective" + c.noun + "Changed",
     altTextSet: subject + "AltTextSet",
     notFound: c.entity + "NotFound",
     notAttached: subject + "NotAttached"
@@ -40,6 +54,35 @@ function refTypeOf(c) {
   return Stdlib_Option.getOr(c.refType, "Reventless.UploadableImage.t");
 }
 
+function viewTypeOf(c) {
+  if (Stdlib_Option.getOr(c.refType, "Reventless.UploadableImage.t").includes("Image")) {
+    return "Reventless.CaptionedImage.t";
+  } else {
+    return Stdlib_Option.getOr(c.refType, "Reventless.UploadableImage.t");
+  }
+}
+
+function setFieldOf(c) {
+  return c.file + "s";
+}
+
+let selectionBinding = "selected";
+
+function selectionTypeOf(_c) {
+  return `@s.matches(` + selectionBinding + `) string`;
+}
+
+function contentArgOf(c) {
+  let ref = Stdlib_Option.getOr(c.refType, "Reventless.UploadableImage.t");
+  if (ref.includes("Image")) {
+    return `~content=Reventless.Semantic.Id.imageRef, `;
+  } else if (ref.includes("File")) {
+    return `~content=Reventless.Semantic.Id.fileRef, `;
+  } else {
+    return "";
+  }
+}
+
 function commandAttributes(c) {
   let a = c.authorize;
   if (a !== undefined) {
@@ -49,18 +92,32 @@ function commandAttributes(c) {
   }
 }
 
-function commandTransitionBinding(c) {
+function commandNames(c) {
   let n = namesOf(c);
-  let arms = [
-    n.attachCmd,
-    n.removeCmd,
-    n.setPrimaryCmd,
-    n.setAltTextCmd
-  ].map(cmd => `  | ` + cmd + `(_)`).join("\n");
+  if (Stdlib_Option.getOr(c.cardinality, "Many") === "Single") {
+    return [
+      n.attachCmd,
+      n.removeCmd,
+      n.setAltTextCmd
+    ];
+  } else {
+    return [
+      n.attachCmd,
+      n.removeCmd,
+      n.setPrimaryCmd,
+      n.setAltTextCmd
+    ];
+  }
+}
+
+function commandTransitionBinding(c) {
+  let arms = commandNames(c).map(cmd => `  | ` + cmd + `(_)`).join("\n");
+  let t = c.lifecycleType;
+  let lifecycleType = t !== undefined ? c.view + `.` + t : c.view + `.<lifecycle>  // TODO(graft): the enum's name`;
   let states = c.transition;
   if (states !== undefined) {
     return [
-      `type lifecycleState = ` + c.view + `.<lifecycle>  // TODO(graft): the enum's name`,
+      `type lifecycleState = ` + lifecycleType,
       `let commandTransition = (command: command): Reventless.Transition.t<lifecycleState> => {`,
       `  open Reventless.Transition`,
       `  switch command {`,
@@ -96,13 +153,28 @@ function lines(ls) {
 function sliceSpec(c) {
   let n = namesOf(c);
   let ref = Stdlib_Option.getOr(c.refType, "Reventless.UploadableImage.t");
+  let sel = selectionTypeOf(c);
+  let single = Stdlib_Option.getOr(c.cardinality, "Many") === "Single";
   let attrs = commandAttributes(c);
   let createdArm = Stdlib_Option.getOr(c.createdCarriesEntityId, true) ? `  | ` + c.created + `({ ` + c.entityId + `: string})` : `  | ` + c.created;
+  let primaryArm = prefix => {
+    if (single) {
+      return [];
+    } else {
+      return [`  | ` + n.primarySet + `({ ` + prefix + c.file + `: ` + ref + `})`];
+    }
+  };
+  let headline = single ? [
+      `// ` + n.slice + ` StateChangeSlice: ` + c.entity + `'s single attachment — set it, remove`,
+      `// it, caption it. A graft of the Attachments trait; the set's rules are the`
+    ] : [
+      `// ` + n.slice + ` StateChangeSlice: ` + c.entity + `'s attachment set — attach, remove,`,
+      `// choose the primary, caption. A graft of the Attachments trait; the rules are`
+    ];
   return Belt_Array.concatMany([
+    headline,
     [
-      `// ` + n.slice + ` StateChangeSlice: ` + c.entity + `'s attachment set — attach, remove,`,
-      `// choose the primary, caption. A graft of the Attachments trait; the set's rules`,
-      `// are the trait's and are asserted by its conformance suite, bound in the tests.`,
+      `// trait's and are asserted by its conformance suite, bound in the tests.`,
       `//`,
       `// Emitted by the trait. Everything below is this host's own vocabulary, so it is`,
       `// ordinary source from here on — edit it freely.`,
@@ -112,19 +184,44 @@ function sliceSpec(c) {
       `@schema`,
       `type consumedEvent =`,
       createdArm,
-      `  | ` + n.attached + `({ ` + c.file + `: string})`,
-      `  | ` + n.removed + `({ ` + c.file + `: string})`,
-      `  | ` + n.primarySet + `({ ` + c.file + `: string})`,
-      `  | ` + n.altTextSet + `({ ` + c.file + `: string, altText: string})`,
+      `  | ` + n.attached + `({ ` + c.file + `: ` + ref + `})`,
+      `  | ` + n.removed + `({ ` + c.file + `: ` + ref + `})`
+    ],
+    primaryArm(""),
+    [
+      `  | ` + n.altTextSet + `({ ` + c.file + `: ` + ref + `, altText: string})`,
+      `  | ` + n.effectiveChanged + `({ ` + c.file + `?: ` + ref + `})`,
       `  // TODO(graft): add the events this host's own refusal turns on — whatever`,
       `  // moves it into a state where attachments may not be changed.`,
-      ``,
+      ``
+    ],
+    single ? [
+        `// One reference field, on ` + n.attachCmd + `, and it accepts a new file — so`,
+        `// it is typed as the uploadable it is and a form binds an upload input to it.`,
+        `// Neither other command names a reference: with one attachment there is`,
+        `// nothing to choose between, and asking a caller to name it would be asking`,
+        `// them to repeat what the row already says.`
+      ] : [
+        `// The reference fields divide into two kinds, and the division is the point.`,
+        `// The one on ` + n.attachCmd + ` accepts a new file, so it is typed as the`,
+        `// uploadable it is and a form binds an upload input to it. The others name a`,
+        `// file the row ALREADY holds, so they are typed as selections out of`,
+        `// \`` + (c.file + "s") + `\` and a form offers those instead of an uploader.`,
+        `//`,
+        `// Bound once rather than spelled three times: the collection is one answer,`,
+        `// and three copies are three chances for one to name a field that has moved.`,
+        `let ` + selectionBinding + ` = Reventless.MemberRef.of_(~view="` + c.view + `", ` + contentArgOf(c) + `~field="` + (c.file + "s") + `")`,
+        ``
+      ],
+    [
       `@schema`,
       `type command =`,
       attrs + n.attachCmd + `({ ` + c.entityId + `: string, ` + c.file + `: ` + ref + `, altText?: string})`,
-      attrs + n.removeCmd + `({ ` + c.entityId + `: string, ` + c.file + `: ` + ref + `})`,
-      attrs + n.setPrimaryCmd + `({ ` + c.entityId + `: string, ` + c.file + `: ` + ref + `})`,
-      attrs + n.setAltTextCmd + `({ ` + c.entityId + `: string, ` + c.file + `: ` + ref + `, altText: string})`,
+      single ? attrs + n.removeCmd + `({ ` + c.entityId + `: string})` : attrs + n.removeCmd + `({ ` + c.entityId + `: string, ` + c.file + `: ` + sel + `})`
+    ],
+    single ? [] : [attrs + n.setPrimaryCmd + `({ ` + c.entityId + `: string, ` + c.file + `: ` + sel + `})`],
+    [
+      single ? attrs + n.setAltTextCmd + `({ ` + c.entityId + `: string, altText: string})` : attrs + n.setAltTextCmd + `({ ` + c.entityId + `: string, ` + c.file + `: ` + sel + `, altText: string})`,
       ``,
       `@schema`,
       `type error =`,
@@ -135,9 +232,15 @@ function sliceSpec(c) {
       `@schema`,
       `type event =`,
       `  | ` + n.attached + `({ ` + c.entityId + `: string, ` + c.file + `: ` + ref + `, altText?: string})`,
-      `  | ` + n.removed + `({ ` + c.entityId + `: string, ` + c.file + `: ` + ref + `})`,
-      `  | ` + n.primarySet + `({ ` + c.entityId + `: string, ` + c.file + `: ` + ref + `})`,
+      `  | ` + n.removed + `({ ` + c.entityId + `: string, ` + c.file + `: ` + ref + `})`
+    ],
+    primaryArm(c.entityId + `: string, `),
+    [
       `  | ` + n.altTextSet + `({ ` + c.entityId + `: string, ` + c.file + `: ` + ref + `, altText: string})`,
+      `  // The member a reader should now show, or none. A conclusion rather than a`,
+      `  // decision: most of the moves that change it — a first attachment, a removal`,
+      `  // promoting the next — are nobody's choice, so nothing else announces them.`,
+      `  | ` + n.effectiveChanged + `({ ` + c.entityId + `: string, ` + c.file + `?: ` + ref + `})`,
       ``
     ],
     commandTransitionBinding(c),
@@ -153,180 +256,301 @@ function sliceSpec(c) {
 
 function sliceBehavior(c) {
   let n = namesOf(c);
-  return [
-    `@@reventless.behavior`,
-    ``,
-    `// The set's rules are the trait's. What is left here is this host's own refusal`,
-    `// and the mapping between its constructors and the trait's ops and facts.`,
-    `module Attachments = TraitAttachments.Attachments_Rules`,
-    ``,
-    `type state = {exists: bool, attachments: Attachments.t}`,
-    ``,
-    `let initialState = {exists: false, attachments: Attachments.empty}`,
-    ``,
-    `let evolve = (state, event) => {`,
-    `  let fold = fact => {...state, attachments: state.attachments->Attachments.evolve(fact)}`,
-    `  switch event {`,
-    `  | ` + c.created + `(_) => {...state, exists: true}`,
-    `  | ` + n.attached + `({` + c.file + `}) => fold(Attached({ref: ` + c.file + `, altText: None}))`,
-    `  | ` + n.removed + `({` + c.file + `}) => fold(Removed({ref: ` + c.file + `}))`,
-    `  | ` + n.primarySet + `({` + c.file + `}) => fold(PrimarySet({ref: ` + c.file + `}))`,
-    `  | ` + n.altTextSet + `({` + c.file + `, altText}) => fold(AltTextSet({ref: ` + c.file + `, altText}))`,
-    `  // TODO(graft): fold this host's own events into its own state.`,
-    `  }`,
-    `}`,
-    ``,
-    `let toOp = command =>`,
-    `  switch command {`,
-    `  | ` + n.attachCmd + `({` + c.entityId + `, ` + c.file + `, altText: ?altText}) => (`,
-    `      ` + c.entityId + `,`,
-    `      Attachments.Attach({ref: ` + c.file + `, altText}),`,
-    `    )`,
-    `  | ` + n.removeCmd + `({` + c.entityId + `, ` + c.file + `}) => (`,
-    `      ` + c.entityId + `,`,
-    `      Attachments.Remove({ref: ` + c.file + `}),`,
-    `    )`,
-    `  | ` + n.setPrimaryCmd + `({` + c.entityId + `, ` + c.file + `}) => (`,
-    `      ` + c.entityId + `,`,
-    `      Attachments.SetPrimary({ref: ` + c.file + `}),`,
-    `    )`,
-    `  | ` + n.setAltTextCmd + `({` + c.entityId + `, ` + c.file + `, altText}) => (`,
-    `      ` + c.entityId + `,`,
-    `      Attachments.SetAltText({ref: ` + c.file + `, altText}),`,
-    `    )`,
-    `  }`,
-    ``,
-    `let toEvent = (` + c.entityId + `, fact) =>`,
-    `  switch fact {`,
-    `  | Attachments.Attached({ref, altText}) =>`,
-    `    ` + n.attached + `({` + c.entityId + `, ` + c.file + `: ref, altText: ?altText})`,
-    `  | Attachments.Removed({ref}) => ` + n.removed + `({` + c.entityId + `, ` + c.file + `: ref})`,
-    `  | Attachments.PrimarySet({ref}) => ` + n.primarySet + `({` + c.entityId + `, ` + c.file + `: ref})`,
-    `  | Attachments.AltTextSet({ref, altText}) =>`,
-    `    ` + n.altTextSet + `({` + c.entityId + `, ` + c.file + `: ref, altText})`,
-    `  }`,
-    ``,
-    `let decide = (state, command) =>`,
-    `  if !state.exists {`,
-    `    Error(` + n.notFound + `)`,
-    `  } else {`,
-    `    // TODO(graft): this host's own refusal goes here, ahead of the set's rules —`,
-    `    // an \`else if\` returning the error added above. A graft with no extra refusal`,
-    `    // is a complete graft, so leaving this is legitimate.`,
-    `    let (` + c.entityId + `, op) = toOp(command)`,
-    `    switch state.attachments->Attachments.decide(op) {`,
-    `    | Error(#NotAttached) => Error(` + n.notAttached + `)`,
-    `    | Ok(None) => Ok([])`,
-    `    | Ok(Some(fact)) => Ok([toEvent(` + c.entityId + `, fact)])`,
-    `    }`,
-    `  }`,
-    ``
-  ].join("\n");
+  let single = Stdlib_Option.getOr(c.cardinality, "Many") === "Single";
+  return Belt_Array.concatMany([
+    [
+      `@@reventless.behavior`,
+      ``,
+      `// The set's rules are the trait's. What is left here is this host's own refusal`,
+      `// and the mapping between its constructors and the trait's ops and facts.`,
+      `module Attachments = TraitAttachments.Attachments_Rules`,
+      ``,
+      `type state = {exists: bool, attachments: Attachments.t}`,
+      ``,
+      `let initialState = {exists: false, attachments: Attachments.empty}`,
+      ``,
+      `let evolve = (state, event) => {`,
+      `  let fold = fact => {...state, attachments: state.attachments->Attachments.evolve(fact)}`,
+      `  switch event {`,
+      Stdlib_Option.getOr(c.createdCarriesEntityId, true) ? `  | ` + c.created + `(_) => {...state, exists: true}` : `  | ` + c.created + ` => {...state, exists: true}`,
+      `  | ` + n.attached + `({` + c.file + `}) => fold(Attached({ref: ` + c.file + `, altText: None}))`,
+      `  | ` + n.removed + `({` + c.file + `}) => fold(Removed({ref: ` + c.file + `}))`
+    ],
+    single ? [] : [`  | ` + n.primarySet + `({` + c.file + `}) => fold(PrimarySet({ref: ` + c.file + `}))`],
+    [
+      `  | ` + n.altTextSet + `({` + c.file + `, altText}) => fold(AltTextSet({ref: ` + c.file + `, altText}))`,
+      `  | ` + n.effectiveChanged + `({` + c.file + `: ?ref}) => fold(EffectiveChanged({ref: ref}))`,
+      `  // TODO(graft): fold this host's own events into its own state.`,
+      `  }`,
+      `}`,
+      ``,
+      `let toOp = command =>`,
+      `  switch command {`,
+      `  | ` + n.attachCmd + `({` + c.entityId + `, ` + c.file + `, altText: ?altText}) => (`,
+      `      ` + c.entityId + `,`,
+      `      Attachments.Attach({ref: ` + c.file + `, altText}),`,
+      `    )`
+    ],
+    single ? [`  | ` + n.removeCmd + `({` + c.entityId + `}) => (` + c.entityId + `, Attachments.Clear)`] : [
+        `  | ` + n.removeCmd + `({` + c.entityId + `, ` + c.file + `}) => (`,
+        `      ` + c.entityId + `,`,
+        `      Attachments.Remove({ref: ` + c.file + `}),`,
+        `    )`,
+        `  | ` + n.setPrimaryCmd + `({` + c.entityId + `, ` + c.file + `}) => (`,
+        `      ` + c.entityId + `,`,
+        `      Attachments.SetPrimary({ref: ` + c.file + `}),`,
+        `    )`
+      ],
+    single ? [
+        `  | ` + n.setAltTextCmd + `({` + c.entityId + `, altText}) => (`,
+        `      ` + c.entityId + `,`,
+        `      Attachments.SetPrimaryAltText({altText: altText}),`,
+        `    )`
+      ] : [
+        `  | ` + n.setAltTextCmd + `({` + c.entityId + `, ` + c.file + `, altText}) => (`,
+        `      ` + c.entityId + `,`,
+        `      Attachments.SetAltText({ref: ` + c.file + `, altText}),`,
+        `    )`
+      ],
+    [
+      `  }`,
+      ``,
+      `let toEvent = (` + c.entityId + `, fact) =>`,
+      `  switch fact {`,
+      `  | Attachments.Attached({ref, altText}) =>`,
+      `    ` + (
+        single ? "Some(" : ""
+      ) + n.attached + `({` + c.entityId + `, ` + c.file + `: ref, altText: ?altText})` + (
+        single ? ")" : ""
+      ),
+      `  | Attachments.Removed({ref}) => ` + (
+        single ? `Some(` + n.removed + `({` + c.entityId + `, ` + c.file + `: ref}))` : n.removed + `({` + c.entityId + `, ` + c.file + `: ref})`
+      )
+    ],
+    single ? [
+        `  // Unreachable: no command of this graft chooses a primary, because a set`,
+        `  // of one has nothing to choose between. It contributes no event.`,
+        `  | Attachments.PrimarySet(_) => None`
+      ] : [`  | Attachments.PrimarySet({ref}) => ` + n.primarySet + `({` + c.entityId + `, ` + c.file + `: ref})`],
+    [
+      `  | Attachments.AltTextSet({ref, altText}) =>`,
+      `    ` + (
+        single ? "Some(" : ""
+      ) + n.altTextSet + `({` + c.entityId + `, ` + c.file + `: ref, altText})` + (
+        single ? ")" : ""
+      ),
+      `  | Attachments.EffectiveChanged({ref}) =>`,
+      `    ` + (
+        single ? "Some(" : ""
+      ) + n.effectiveChanged + `({` + c.entityId + `, ` + c.file + `: ?ref})` + (
+        single ? ")" : ""
+      ),
+      `  }`,
+      ``,
+      `let decide = (state, command) =>`,
+      `  if !state.exists {`,
+      `    Error(` + n.notFound + `)`,
+      `  } else {`,
+      `    // TODO(graft): this host's own refusal goes here, ahead of the set's rules —`,
+      `    // an \`else if\` returning the error added above. A graft with no extra refusal`,
+      `    // is a complete graft, so leaving this is legitimate.`,
+      `    let (` + c.entityId + `, op) = toOp(command)`,
+      single ? `    switch state.attachments->Attachments.decide(~cardinality=Single, op) {` : `    switch state.attachments->Attachments.decide(op) {`,
+      `    | Error(#NotAttached) => Error(` + n.notAttached + `)`,
+      single ? `    | Ok(facts) => Ok(facts->Array.filterMap(toEvent(` + c.entityId + `, _)))` : `    | Ok(facts) => Ok(facts->Array.map(toEvent(` + c.entityId + `, _)))`,
+      `    }`,
+      `  }`,
+      ``
+    ]
+  ]).join("\n");
 }
 
 function conformanceBinding(c) {
   let n = namesOf(c);
+  let single = Stdlib_Option.getOr(c.cardinality, "Many") === "Single";
   let id = "e1";
   let refA = Stdlib_Option.getOr(c.refA, `/uploads/00000000-0000-4000-8000-000000000001/a`);
   let refB = Stdlib_Option.getOr(c.refB, `/uploads/00000000-0000-4000-8000-000000000002/b`);
   let createdValue = Stdlib_Option.getOr(c.createdCarriesEntityId, true) ? c.created + `({ ` + c.entityId + `: "` + id + `"})` : c.created;
-  return [
-    `// The Attachments trait's conformance suite, bound to \`` + n.slice + `\`.`,
-    `// Emitted whole: every name here is one the graft already declared.`,
-    ``,
-    `module Binding = {`,
-    `  type ref = string`,
-    `  let refA = "` + refA + `"`,
-    `  let refB = "` + refB + `"`,
-    ``,
-    `  module Spec = ` + n.slice,
-    `  module Behavior = ` + n.slice + `_Behavior`,
-    ``,
-    `  // Annotated: the slice consumes and emits same-named constructors.`,
-    `  let created: array<` + n.slice + `.consumedEvent> = [` + createdValue + `]`,
-    `  let attachedC = (ref): ` + n.slice + `.consumedEvent => ` + n.attached + `({ ` + c.file + `: ref})`,
-    `  let removedC = (ref): ` + n.slice + `.consumedEvent => ` + n.removed + `({ ` + c.file + `: ref})`,
-    `  let primarySetC = (ref): ` + n.slice + `.consumedEvent => ` + n.primarySet + `({ ` + c.file + `: ref})`,
-    `  let altTextSetC = (ref, altText): ` + n.slice + `.consumedEvent =>`,
-    `    ` + n.altTextSet + `({ ` + c.file + `: ref, altText})`,
-    ``,
-    `  let attach = ref => ` + n.slice + `.` + n.attachCmd + `({ ` + c.entityId + `: "` + id + `", ` + c.file + `: ref})`,
-    `  let remove = ref => ` + n.slice + `.` + n.removeCmd + `({ ` + c.entityId + `: "` + id + `", ` + c.file + `: ref})`,
-    `  let setPrimary = ref =>`,
-    `    ` + n.slice + `.` + n.setPrimaryCmd + `({ ` + c.entityId + `: "` + id + `", ` + c.file + `: ref})`,
-    `  let setAltText = (ref, altText) =>`,
-    `    ` + n.slice + `.` + n.setAltTextCmd + `({ ` + c.entityId + `: "` + id + `", ` + c.file + `: ref, altText})`,
-    ``,
-    `  let attached = ref => ` + n.slice + `.` + n.attached + `({ ` + c.entityId + `: "` + id + `", ` + c.file + `: ref})`,
-    `  let removed = ref => ` + n.slice + `.` + n.removed + `({ ` + c.entityId + `: "` + id + `", ` + c.file + `: ref})`,
-    `  let primarySet = ref =>`,
-    `    ` + n.slice + `.` + n.primarySet + `({ ` + c.entityId + `: "` + id + `", ` + c.file + `: ref})`,
-    `  let altTextSet = (ref, altText) =>`,
-    `    ` + n.slice + `.` + n.altTextSet + `({ ` + c.entityId + `: "` + id + `", ` + c.file + `: ref, altText})`,
-    `  let notAttached = ` + n.slice + `.` + n.notAttached,
-    `}`,
-    ``,
-    `module Conformance = TraitAttachments.Attachments_Conformance.Make(Binding)`,
-    ``,
-    `Conformance.register()`,
-    ``
-  ].join("\n");
+  return Belt_Array.concatMany([
+    [
+      `// The Attachments trait's conformance suite, bound to \`` + n.slice + `\`.`,
+      `// Emitted whole: every name here is one the graft already declared.`,
+      ``,
+      `module Binding = {`,
+      `  type ref = string`,
+      `  let refA = "` + refA + `"`,
+      `  let refB = "` + refB + `"`,
+      ``,
+      `  module Spec = ` + n.slice,
+      `  module Behavior = ` + n.slice + `_Behavior`,
+      ``,
+      `  // Annotated: the slice consumes and emits same-named constructors.`,
+      `  // The same facts as the slice consumes them: no ` + c.entityId + `, because the`,
+      `  // partition already says which entity they belong to.`,
+      `  module Consumed = {`,
+      `    let created: array<` + n.slice + `.consumedEvent> = [` + createdValue + `]`,
+      `    let attached = (ref): ` + n.slice + `.consumedEvent => ` + n.attached + `({ ` + c.file + `: ref})`,
+      `    let removed = (ref): ` + n.slice + `.consumedEvent => ` + n.removed + `({ ` + c.file + `: ref})`
+    ],
+    single ? [] : [`    let primarySet = (ref): ` + n.slice + `.consumedEvent => ` + n.primarySet + `({ ` + c.file + `: ref})`],
+    [
+      `    let altTextSet = (ref, altText): ` + n.slice + `.consumedEvent =>`,
+      `      ` + n.altTextSet + `({ ` + c.file + `: ref, altText})`,
+      `    let effectiveChanged = (ref): ` + n.slice + `.consumedEvent =>`,
+      `      ` + n.effectiveChanged + `({ ` + c.file + `: ?ref})`,
+      `  }`,
+      ``,
+      `  let attach = ref => ` + n.slice + `.` + n.attachCmd + `({ ` + c.entityId + `: "` + id + `", ` + c.file + `: ref})`
+    ],
+    single ? [`  let clear = ` + n.slice + `.` + n.removeCmd + `({ ` + c.entityId + `: "` + id + `"})`] : [
+        `  let remove = ref => ` + n.slice + `.` + n.removeCmd + `({ ` + c.entityId + `: "` + id + `", ` + c.file + `: ref})`,
+        `  let setPrimary = ref =>`,
+        `    ` + n.slice + `.` + n.setPrimaryCmd + `({ ` + c.entityId + `: "` + id + `", ` + c.file + `: ref})`
+      ],
+    [
+      single ? `  let setAltText = altText => ` + n.slice + `.` + n.setAltTextCmd + `({ ` + c.entityId + `: "` + id + `", altText})` : `  let setAltText = (ref, altText) =>\n    ` + n.slice + `.` + n.setAltTextCmd + `({ ` + c.entityId + `: "` + id + `", ` + c.file + `: ref, altText})`,
+      ``,
+      `  let attached = ref => ` + n.slice + `.` + n.attached + `({ ` + c.entityId + `: "` + id + `", ` + c.file + `: ref})`,
+      `  let removed = ref => ` + n.slice + `.` + n.removed + `({ ` + c.entityId + `: "` + id + `", ` + c.file + `: ref})`
+    ],
+    single ? [] : [
+        `  let primarySet = ref =>`,
+        `    ` + n.slice + `.` + n.primarySet + `({ ` + c.entityId + `: "` + id + `", ` + c.file + `: ref})`
+      ],
+    [
+      `  let altTextSet = (ref, altText) =>`,
+      `    ` + n.slice + `.` + n.altTextSet + `({ ` + c.entityId + `: "` + id + `", ` + c.file + `: ref, altText})`,
+      `  let effectiveChanged = ref =>`,
+      `    ` + n.slice + `.` + n.effectiveChanged + `({ ` + c.entityId + `: "` + id + `", ` + c.file + `: ?ref})`,
+      `  let notAttached = ` + n.slice + `.` + n.notAttached,
+      `}`,
+      ``,
+      single ? `module Conformance = TraitAttachments.Attachments_Conformance.MakeSingle(Binding)` : `module Conformance = TraitAttachments.Attachments_Conformance.Make(Binding)`,
+      ``,
+      `Conformance.register()`,
+      ``
+    ]
+  ]).join("\n");
 }
 
-function projectionPatch(c) {
+function singleProjectionPatch(c) {
   let n = namesOf(c);
   return {
-    into: `StateViewSliceStream/` + c.view + `_Projection.res`,
-    at: `the projection's \`switch\`, and two fields on \`` + c.view + `\`'s state`,
+    into: `StateViewStream/` + c.view + `_Projection.res`,
+    at: `the projection's \`switch\`, and one field on \`` + c.view + `\`'s state`,
     contents: [
-      `// On the view's state, two fields — the set, and its primary as one string.`,
-      `// The second is not redundancy: a card, a gallery tile and a reference cell`,
-      `// each read one image-semantic string per row, so without it every tile is blank.`,
+      `// On the view's state, one field — the reference and its text, in one value.`,
+      `// No collection: this entity holds one attachment, so the field a card, a`,
+      `// gallery tile and a list cell read IS the whole of what it has.`,
       `//`,
-      `//   ` + c.file + `s: array<{` + c.file + `: string, altText?: string}>,`,
-      `//   ` + c.file + `?: string,`,
+      `//   ` + c.file + `?: ` + viewTypeOf(c) + `,`,
       ``,
       `| ` + n.attached + `({` + c.entityId + `, ` + c.file + `, altText: ?altText}) =>`,
       `  Update(` + c.entityId + `, state => {`,
-      `    let ` + c.file + `s = Array.concat(state.` + c.file + `s, [{` + c.file + `: ` + c.file + `, altText: ?altText}])`,
-      `    {...state, ` + c.file + `s, ` + c.file + `: ?withPrimary(` + c.file + `s, state.primaryChosen)}`,
+      `    ...state,`,
+      `    ` + c.file + `: {ref: ` + c.file + `, altText: ?altText},`,
       `  })`,
       `| ` + n.removed + `({` + c.entityId + `, ` + c.file + `}) =>`,
+      `  Update(` + c.entityId + `, state =>`,
+      `    // Guarded on the reference: a removal that names something this row no`,
+      `    // longer holds — the first half of a replacement, arriving late — must not`,
+      `    // blank the one it does.`,
+      `    heldRef(state) == Some(` + c.file + `) ? {...state, ` + c.file + `: ?None} : state`,
+      `  )`,
+      `| ` + n.altTextSet + `({` + c.entityId + `, ` + c.file + `, altText}) =>`,
+      `  Update(` + c.entityId + `, state =>`,
+      `    switch state.` + c.file + ` {`,
+      `    | Some(held) if held.ref == ` + c.file + ` => {...state, ` + c.file + `: {...held, altText}}`,
+      `    | _ => state`,
+      `    }`,
+      `  )`,
+      ``,
+      `// The reference this row holds, if it holds one. Named because both guards`,
+      `// above ask the same question of a value that is no longer the reference itself.`,
+      `let heldRef = (state: ` + c.view + `.state) => state.` + c.file + `->Option.map(held => held.ref)`
+    ].join("\n")
+  };
+}
+
+function manyProjectionPatch(c) {
+  let n = namesOf(c);
+  let set = c.file + "s";
+  return {
+    into: `StateViewStream/` + c.view + `_Projection.res`,
+    at: `the projection's \`switch\`, and one field on \`` + c.view + `\`'s state`,
+    contents: [
+      `// On the view's state, one field — the set, primary first.`,
+      `//`,
+      `// The primary is the FIRST member rather than a scalar beside the set. That is`,
+      `// what a card, a gallery tile and a list cell read, so there is no second field`,
+      `// to keep in step with the set and no arm that can forget to. The text rides`,
+      `// inside each member for the same reason: a cell renderer is handed a field and`,
+      `// a value and never the row, so a caption in a sibling field is one no cell can`,
+      `// draw.`,
+      `//`,
+      `// What it costs, stated plainly: attachment order stops being readable off the`,
+      `// view. The log still has it.`,
+      `//`,
+      `//   ` + set + `: array<` + viewTypeOf(c) + `>,`,
+      ``,
+      `// Appended, so the first attached is the primary until one is chosen.`,
+      `| ` + n.attached + `({` + c.entityId + `, ` + c.file + `, altText: ?altText}) =>`,
+      `  Update(` + c.entityId + `, state =>`,
+      `    state.` + set + `->Array.some(m => m.ref == ` + c.file + `)`,
+      `      ? state`,
+      `      : {`,
+      `          ...state,`,
+      `          ` + set + `: state.` + set + `->Array.concat([{ref: ` + c.file + `, altText: ?altText}]),`,
+      `        }`,
+      `  )`,
+      `// Removing the head promotes the next member with no arm to say so.`,
+      `| ` + n.removed + `({` + c.entityId + `, ` + c.file + `}) =>`,
       `  Update(` + c.entityId + `, state => {`,
-      `    let ` + c.file + `s = state.` + c.file + `s->Array.filter(m => m.` + c.file + ` != ` + c.file + `)`,
-      `    {...state, ` + c.file + `s, ` + c.file + `: ?withPrimary(` + c.file + `s, state.primaryChosen)}`,
+      `    ...state,`,
+      `    ` + set + `: state.` + set + `->Array.filter(m => m.ref != ` + c.file + `),`,
       `  })`,
       `| ` + n.primarySet + `({` + c.entityId + `, ` + c.file + `}) =>`,
-      `  Update(` + c.entityId + `, state => {...state, ` + c.file + `: Some(` + c.file + `)})`,
+      `  Update(` + c.entityId + `, state => primaryFirst(state, ` + c.file + `))`,
       `| ` + n.altTextSet + `({` + c.entityId + `, ` + c.file + `, altText}) =>`,
       `  Update(` + c.entityId + `, state => {`,
       `    ...state,`,
-      `    ` + c.file + `s: state.` + c.file + `s->Array.map(m =>`,
-      `      m.` + c.file + ` == ` + c.file + ` ? {...m, altText} : m`,
-      `    ),`,
+      `    ` + set + `: state.` + set + `->Array.map(m => m.ref == ` + c.file + ` ? {...m, altText} : m),`,
       `  })`,
       ``,
-      `// The primary a reader should show: the one chosen, else the first attached —`,
-      `// the same rule the trait applies, over the view's own rows.`,
-      `let withPrimary = (members, chosen) =>`,
-      `  TraitAttachments.Attachments_Rules.primaryOf(`,
+      `// Choosing the primary is moving it to the front — the trait's rule, applied`,
+      `// over the view's rows. The only arm that reorders; the rest leave the head`,
+      `// where they found it.`,
+      `let primaryFirst = (state: ` + c.view + `.state, chosen) => {`,
+      `  ...state,`,
+      `  ` + set + `: TraitAttachments.Attachments_Rules.primaryFirst(`,
       `    ~chosen,`,
-      `    ~attached=members->Array.map(m => m.` + c.file + `),`,
-      `  )`
+      `    ~members=state.` + set + `,`,
+      `    ~ref=m => m.ref,`,
+      `  ),`,
+      `}`
     ].join("\n")
   };
 }
 
+function projectionPatch(c) {
+  if (Stdlib_Option.getOr(c.cardinality, "Many") === "Single") {
+    return singleProjectionPatch(c);
+  } else {
+    return manyProjectionPatch(c);
+  }
+}
+
 function emit(config, into, tests) {
   let n = namesOf(config);
   return {
     files: [
       {
-        path: into + `/StateChangeSlice/` + n.slice + `.res`,
+        path: into + `/StateChange/` + n.slice + `.res`,
         contents: sliceSpec(config)
       },
       {
-        path: into + `/StateChangeSlice/` + n.slice + `_Behavior.res`,
+        path: into + `/StateChange/` + n.slice + `_Behavior.res`,
         contents: sliceBehavior(config)
       },
       {
@@ -340,14 +564,24 @@ function emit(config, into, tests) {
 
 export {
   configSchema,
+  cardinalityOf,
+  isSingle,
   namesOf,
   refTypeOf,
+  viewTypeOf,
+  setFieldOf,
+  selectionBinding,
+  selectionTypeOf,
+  contentArgOf,
   commandAttributes,
+  commandNames,
   commandTransitionBinding,
   lines,
   sliceSpec,
   sliceBehavior,
   conformanceBinding,
+  singleProjectionPatch,
+  manyProjectionPatch,
   projectionPatch,
   emit,
 }