@yahoo/uds-create-cli 5.64.0 → 5.64.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yahoo/uds-create-cli",
-  "version": "5.64.0",
+  "version": "5.64.2",
   "publishConfig": {
     "access": "public"
   },
@@ -31,10 +31,10 @@
     "@modelcontextprotocol/sdk": "^1.32.2",
     "@orpc/client": "^1.13.9",
     "@orpc/contract": "^1.13.9",
-    "@yahoo/uds-create-config": "5.64.0",
-    "@yahoo/uds-create-loader": "5.64.0",
-    "@yahoo/uds-create-types": "5.64.0",
-    "@yahoo/uds-create-utils": "5.64.0",
+    "@yahoo/uds-create-config": "5.64.2",
+    "@yahoo/uds-create-loader": "5.64.2",
+    "@yahoo/uds-create-types": "5.64.2",
+    "@yahoo/uds-create-utils": "5.64.2",
     "esbuild": "^0.27.4",
     "ts-morph": "^27.0.2",
     "get-tsconfig": "^4.10.0",
@@ -53,9 +53,9 @@
   },
   "udsSchemaVersion": 20261027205147,
   "optionalDependencies": {
-    "@yahoo/uds-create-cli-darwin-arm64": "5.64.0",
-    "@yahoo/uds-create-cli-darwin-x64": "5.64.0",
-    "@yahoo/uds-create-cli-linux-arm64": "5.64.0",
-    "@yahoo/uds-create-cli-linux-x64": "5.64.0"
+    "@yahoo/uds-create-cli-darwin-arm64": "5.64.2",
+    "@yahoo/uds-create-cli-darwin-x64": "5.64.2",
+    "@yahoo/uds-create-cli-linux-arm64": "5.64.2",
+    "@yahoo/uds-create-cli-linux-x64": "5.64.2"
   }
 }

package/subprocess/transform-runner.mjs

@@ -64459,6 +64459,15 @@ function heldElsewhere(config2, { slug: slug2, kind, path: path2 }) {
 }
 function danglingDirectives(config2) {
   const found = [];
+  const reached = /* @__PURE__ */ new Map();
+  const reachedComponents = (slug2) => {
+    let paths = reached.get(slug2);
+    if (!paths) {
+      paths = new Set(config2.sourceClosure(slug2, "component").map(pathOf2));
+      reached.set(slug2, paths);
+    }
+    return paths;
+  };
   for (const slug2 of config2.sourceSlugs()) {
     const source = config2.liveSourceFor(slug2);
     if (!source) continue;
@@ -64480,6 +64489,25 @@ function danglingDirectives(config2) {
           path: path2
         });
         if (heldBy === void 0) continue;
+        if (kind === "component" && reachedComponents(slug2).has(path2)) {
+          const copy = config2.pinCopyOf({
+            slug: slug2,
+            kind,
+            path: path2
+          });
+          if (copy && "unreadable" in copy) {
+            found.push({
+              slug: slug2,
+              accessor,
+              path: path2,
+              missing: "row",
+              ...heldBy === null ? {} : { heldBy },
+              unreadable: copy.unreadable
+            });
+            continue;
+          }
+          if (copy) continue;
+        }
         found.push({
           slug: slug2,
           accessor,
@@ -78618,7 +78646,7 @@ var sourceVarPrefix = (config2, slug2) => prefixed({
 });
 function linkedVarNaming(config2, slug2) {
   const pinned = sourceVarPrefix(config2, slug2);
-  const source = config2.sourceFor(slug2);
+  const source = config2.drawnSourceFor(slug2);
   const named = /* @__PURE__ */ new Map();
   return (tokenPath) => {
     const hit = named.get(tokenPath);
@@ -90718,6 +90746,8 @@ function objectSchemaOf(schema) {
   }
 }
 var implementedByCache = /* @__PURE__ */ new WeakMap();
+var CONSUMER_TOKENS = "__consumer";
+var drawnSources = /* @__PURE__ */ new WeakMap();
 function implementedBy(config2) {
   const cached2 = implementedByCache.get(config2);
   if (cached2) return cached2;
@@ -95027,6 +95057,104 @@ var Config = class Config2 {
     });
   }
   /**
+  * The source at `slug` as this build draws the copies it still builds of its components that another
+  * row stands in for here, each drawn the way the pin's own row was: with the entry the pin's
+  * `options` lay at its path ({@link pinCopyOf}).
+  *
+  * A product that takes Yahoo OS's Button still builds the Bridge's, which the Bridge's Banner
+  * renders, and the Bridge pin's entry for its Button is what that copy is drawn with. Everything else
+  * is the source's own, so the source itself comes back when no copy carries an entry.
+  */
+  drawnSourceFor(slug2) {
+    const source = this.sourceFor(slug2);
+    if (!source) return void 0;
+    let bySlug = drawnSources.get(this);
+    if (!bySlug) {
+      bySlug = /* @__PURE__ */ new Map();
+      drawnSources.set(this, bySlug);
+    }
+    const cached2 = bySlug.get(slug2);
+    if (cached2) return cached2;
+    const changes = [];
+    for (const { kind, path: path2 } of this.sourceDirectives(slug2)) {
+      const entry = kind === void 0 ? void 0 : this.entityOf(kind);
+      if (kind !== "component" || !entry) continue;
+      const copy = this.pinCopyOf({
+        slug: slug2,
+        kind,
+        path: path2
+      });
+      if (!copy || !("body" in copy)) continue;
+      changes.push({
+        kind,
+        target: "item",
+        path: path2,
+        value: new Entity(path2, copy.body, entry.fieldKeys)
+      });
+      const tokenEntry = this.entityOf("token");
+      for (const [at, cssVariable] of copy.tokens) {
+        if (!tokenEntry) break;
+        changes.push({
+          kind: "token",
+          target: "item",
+          path: at,
+          value: new Entity(at, { cssVariable }, tokenEntry.fieldKeys)
+        });
+      }
+    }
+    const drawn = changes.length === 0 ? source : source.derive({ snapshot: source.state.snapshot.withChanges(changes) });
+    bySlug.set(slug2, drawn);
+    return drawn;
+  }
+  /**
+  * The body `slug`'s copy of `kind:path` is drawn with, spelled as the source spells it: the source's
+  * entity with the entry the pin's `options` lay at the path, read as the pin's row would read it
+  * here. `undefined` when this config holds the pin's row at the path (the row is what's drawn), holds
+  * nothing there, or the pin lays nothing over it.
+  *
+  * A token it names that the source has no name for (one of this config's own, or one it takes
+  * through another pin) is named under {@link CONSUMER_TOKENS} instead, and `tokens` gives each such
+  * path the variable this config's stylesheet declares for it. `unreadable` names any other ref the
+  * source has no name for: the copy can't be drawn with it, so the entry is reported instead.
+  */
+  pinCopyOf({ slug: slug2, kind, path: path2 }) {
+    const stored = this.storedBody(kind, path2);
+    if (stored === void 0 || isRef2(stored) && sourceOf2(stored) === slug2) return;
+    const overlay = this.sourceDirective(slug2, kind, path2).overlay;
+    const source = this.sourceFor(slug2);
+    const theirs = this.theirBody({
+      slug: slug2,
+      kind,
+      path: path2
+    });
+    if (!overlay || !source || !theirs) return void 0;
+    const read = this.derive({ snapshot: this.state.snapshot.withChanges([derivedItemChange(kind, path2, ref(kind, path2, slug2).__ref, overlayBody({
+      overlay,
+      theirs
+    }))]) }).resolve(kind, path2)?.toJSON();
+    if (!read) return void 0;
+    const owned = new Set(source.ownedKinds());
+    const unreadable = [...new Set(collectRefs(read).filter((target2) => sourceOf2(target2) === void 0 && owned.has(kindOf2(target2)) && pathOf2(target2) !== "" && !this.borrowsExactly({ __ref: target2 }, slug2)))];
+    let body = read;
+    const tokens = /* @__PURE__ */ new Map();
+    const others = [];
+    for (const target2 of unreadable) {
+      const path3 = pathOf2(target2);
+      if (kindOf2(target2) !== "token" || !declaresCssVariable(this, path3)) {
+        others.push(target2);
+        continue;
+      }
+      const at = `${CONSUMER_TOKENS}/${path3}`;
+      body = rewriteRefs(body, target2, ref("token", at).__ref);
+      tokens.set(at, cssVar(this, "token", path3));
+    }
+    if (others.length > 0) return { unreadable: others };
+    return {
+      body: rewriteRefSource(body, slug2, void 0),
+      tokens
+    };
+  }
+  /**
   * The group counterpart of {@link heldThroughAnotherPin}: this config holds the group at `path`
   * through another pin, and every member `slug` offers under it is held that way too. A group is a
   * folder over its members, so it is the same folder exactly when they are the same entities.
@@ -97713,12 +97841,13 @@ function planLinkApplied({ config: config2, input: input2 }) {
   ];
   let result = planned.length > 0 ? applied(config2, planned) : void 0;
   if (takes2.length > 0 && result && "failed" in result) throw result.failed;
-  const { dropped, patches: drops } = takes2.length > 0 && result && "config" in result ? directivesTakenFrom({
+  const { dropped, stranded, patches: drops } = takes2.length > 0 && result && "config" in result ? directivesTakenFrom({
     config: config2,
     slug: slug2,
     after: result.config
   }) : {
     dropped: [],
+    stranded: [],
     patches: []
   };
   if (drops.length > 0 && result && "config" in result) result = applied(result.config, drops);
@@ -97738,23 +97867,33 @@ function planLinkApplied({ config: config2, input: input2 }) {
       extended,
       dropped,
       shared,
-      patches
+      patches,
+      ...stranded.length > 0 ? {
+        stranded,
+        blocked: strandedMessage(slug2, stranded)
+      } : {}
     },
-    after: result && "config" in result ? result.config : void 0
+    after: stranded.length === 0 && result && "config" in result ? result.config : void 0
   };
 }
 function directivesTakenFrom({ config: config2, slug: slug2, after: after5 }) {
   const key2 = (at) => `${at.slug}\0${at.accessor}\0${at.path}`;
   const already = new Set(danglingDirectives(config2).map(key2));
   const dropped = [];
+  const stranded = [];
   for (const at of danglingDirectives(after5)) {
     if (at.missing !== "row" || at.heldBy !== slug2 || already.has(key2(at))) continue;
-    dropped.push({
+    const entry = {
       kind: config2.accessors()[at.accessor]?.kind ?? at.accessor,
       path: at.path,
       from: at.slug,
       accessor: at.accessor
+    };
+    if (at.unreadable) stranded.push({
+      ...entry,
+      unreadable: at.unreadable
     });
+    else dropped.push(entry);
   }
   const edits = [];
   for (const pin of new Set(dropped.map((at) => at.from))) {
@@ -97780,9 +97919,15 @@ function directivesTakenFrom({ config: config2, slug: slug2, after: after5 }) {
   }
   return {
     dropped,
+    stranded,
     patches: edits
   };
 }
+function strandedMessage(slug2, stranded) {
+  const named = stranded.map((at) => `${at.from}'s ${at.accessor} entry at "${at.path}" names ${at.unreadable.join(", ")}`).join("; ");
+  const [one] = stranded;
+  return `Can't take through "${slug2}": ${named}. ${stranded.length === 1 && one ? `${one.from} still builds its own ${one.path}, which its components render, and that entry applies to it` : "each pin still builds its own copy, which its components render, and the entry applies to it"}, but Create can draw that copy only with this system's own tokens, not yet with this system's own components, composites or motion presets. Point those values at something the pin links, or remove them from the entry, then take again.`;
+}
 function refusal(error61) {
   const collisions2 = error61.issues.flatMap((issue2) => issue2.collisions ?? []);
   return {
@@ -98662,10 +98807,11 @@ var LinkedSystemDefinition = defineEntity({
       title: (entity) => `Link something from ${entity}`,
       example: linkExample,
       handler: (input2, config2) => {
-        const { plan: { linked, patches }, after: after5 } = planLinkApplied({
+        const { plan: { linked, patches, stranded, blocked }, after: after5 } = planLinkApplied({
           config: config2,
           input: linkPlanInputOf(input2)
         });
+        if (stranded && stranded.length > 0 && blocked) rejectData(blocked, ["onLinked"]);
         if (linked.length > 0 && input2.onLinked === void 0) {
           const named = linked.map((at) => `${at.path} (from ${at.from})`);
           rejectData(`Linking through "${String(input2.path)}" reaches what another linked system provides: ${named.join(", ")}. Say whether to take them (\`onLinked: 'take'\`) or keep them where they come from (\`onLinked: 'keep'\`).`, ["onLinked"]);