@suss/ir-core 0.21.0 → 0.21.1

package/dist/index.js

@@ -20,19 +20,32 @@ import {
   UnitInvocationSemanticsSchema,
   allBehaviors,
   behaviorOf,
+  boundaryNameString,
   busIdentityKey,
   busesAgree,
   channelsPair,
+  dispatchByType,
   ecsContainerInstanceName,
+  fixedTextLength,
   fnIdentityKey,
   formatChannel,
   gqlIdentityKey,
+  hasNameHole,
   methodsAgree,
   metricIdentityKey,
+  namePatternFromSub,
+  namePatternKey,
+  namesAgree,
+  namesNothing,
   normalizePath,
+  parseBoundaryName,
   parseChannel,
   pathAfterOrigin,
   pathShape,
+  patternHole,
+  referenceFromName,
+  referenceName,
+  referenceOf,
   routePathAdmits,
   semconvMappingOf,
   statesAnOrigin,
@@ -41,7 +54,7 @@ import {
   typeDefinitionKey,
   unitIdentityKey,
   withDefinitionsInlined
-} from "./chunk-QHFMZPEG.js";
+} from "./chunk-PPQWK62O.js";
 
 // src/semconv.ts
 function semconvAttributes(binding) {
@@ -79,12 +92,16 @@ function withRewrittenPaths(binding, rewrite) {
     semantics: behavior.rewritePaths(binding.semantics, rewrite)
   };
 }
-function groundedPairingKey(binding, deployedAs) {
+function groundedPairingKey(binding, deployment) {
+  return pairingKey(groundBinding(binding, deployment));
+}
+function groundBinding(binding, deployment) {
   const behavior = behaviorOf(binding.semantics);
-  const grounded = behavior.groundName?.(binding.semantics, deployedAs) ?? null;
-  return pairingKey(
-    grounded === null ? binding : { ...binding, semantics: grounded }
-  );
+  const grounded = behavior.groundName?.(binding.semantics, deployment) ?? null;
+  return grounded === null ? binding : { ...binding, semantics: grounded };
+}
+function nameReference(binding) {
+  return behaviorOf(binding.semantics).nameReference?.(binding.semantics) ?? null;
 }
 function pairingKey(binding) {
   const behavior = behaviorOf(binding.semantics);
@@ -138,141 +155,6 @@ function withinScope(binding, scope) {
   return within === void 0 ? false : within(binding.semantics, scope);
 }
 
-// src/dispatch.ts
-function dispatchByType(table, value) {
-  const handler = table[value.type];
-  return handler(value);
-}
-
-// src/boundaryName.ts
-var HOLE_SPLIT = /(\{[^}]*\})/;
-var SUB_TOKEN = /\$\{([^}]*)\}/g;
-var SUB_ESCAPE = /\$\{!/;
-function isHole(piece) {
-  return piece.startsWith("{") && piece.endsWith("}");
-}
-function parseBoundaryName(name) {
-  const parts = name.split(HOLE_SPLIT).filter((piece) => piece !== "").map(
-    (piece) => isHole(piece) ? { type: "hole", label: piece.slice(1, -1) } : { type: "text", text: piece }
-  );
-  const only = parts.length === 1 ? parts[0] : void 0;
-  if (only !== void 0 && only.type === "hole") {
-    return { type: "reference", path: only.label.split(".") };
-  }
-  if (parts.some((part) => part.type === "hole")) {
-    return { type: "pattern", parts };
-  }
-  return { type: "literal", value: name };
-}
-var partString = {
-  text: (part) => part.text,
-  hole: (part) => patternHole(part.label)
-};
-var nameString = {
-  literal: (name) => name.value,
-  pattern: (name) => name.parts.map((part) => dispatchByType(partString, part)).join(""),
-  reference: (name) => patternHole(name.path.join("."))
-};
-function boundaryNameString(name) {
-  return dispatchByType(nameString, name);
-}
-function patternHole(label) {
-  return `{${label}}`;
-}
-function namePatternFromSub(value) {
-  if (Array.isArray(value)) {
-    return typeof value[0] === "string" ? namePatternFromSub(value[0]) : null;
-  }
-  if (typeof value !== "string") {
-    return null;
-  }
-  if (SUB_ESCAPE.test(value)) {
-    return null;
-  }
-  return value.replace(
-    SUB_TOKEN,
-    (_whole, inner) => patternHole(inner)
-  );
-}
-function namesNothing(name) {
-  return parseBoundaryName(name).type === "reference";
-}
-function hasNameHole(name) {
-  return parseBoundaryName(name).type !== "literal";
-}
-function namePatternKey(name) {
-  return dispatchByType(
-    {
-      literal: (parsed) => parsed.value,
-      pattern: (parsed) => boundaryNameString({
-        type: "pattern",
-        parts: parsed.parts.map(
-          (part) => part.type === "hole" ? { type: "hole", label: "" } : part
-        )
-      }),
-      reference: () => patternHole("")
-    },
-    parseBoundaryName(name)
-  );
-}
-function fixedTextLength(name) {
-  return dispatchByType(
-    {
-      literal: (parsed) => parsed.value.length,
-      pattern: (parsed) => parsed.parts.reduce(
-        (total, part) => total + (part.type === "text" ? part.text.length : 0),
-        0
-      ),
-      reference: () => 0
-    },
-    parseBoundaryName(name)
-  );
-}
-function quote(text) {
-  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function admits(pattern, name) {
-  const source = pattern.parts.map((part) => part.type === "hole" ? ".+" : quote(part.text)).join("");
-  return new RegExp(`^${source}$`).test(name);
-}
-function namesAgree(a, b) {
-  const left = parseBoundaryName(a);
-  const right = parseBoundaryName(b);
-  if (left.type === "reference" || right.type === "reference") {
-    return false;
-  }
-  if (left.type === "pattern" && right.type === "pattern") {
-    return namePatternKey(a) === namePatternKey(b);
-  }
-  if (left.type === "pattern") {
-    return admits(left, b);
-  }
-  if (right.type === "pattern") {
-    return admits(right, a);
-  }
-  return a === b;
-}
-function referenceName(reference) {
-  const path = [reference.root, ...reference.fields];
-  if (path.some((part) => part === "")) {
-    return null;
-  }
-  return boundaryNameString({ type: "reference", path });
-}
-function referenceOf(name) {
-  if (name.type !== "reference") {
-    return null;
-  }
-  const root = name.path[0];
-  if (root === void 0 || name.path.some((part) => part === "")) {
-    return null;
-  }
-  return { root, fields: name.path.slice(1) };
-}
-function referenceFromName(name) {
-  return referenceOf(parseBoundaryName(name));
-}
-
 // src/boundarySpelling.ts
 function resourceNameIn(spelling) {
   if (spelling.startsWith("arn:")) {
@@ -337,6 +219,13 @@ function fileInCodeScope(file, scope) {
   return path === prefix || path.startsWith(`${prefix}/`);
 }
 
+// src/deployment.ts
+var NOTHING_DEPLOYED = {
+  variableFor: () => null,
+  setTo: () => null,
+  pointsAt: () => null
+};
+
 // src/relation.ts
 import { z } from "zod";
 var RelationSchema = z.enum([
@@ -747,6 +636,7 @@ export {
   GraphqlResolverSemanticsSchema,
   MessageBusSemanticsSchema,
   MetricSemanticsSchema,
+  NOTHING_DEPLOYED,
   RelationSchema,
   RestSemanticsSchema,
   RuntimeConfigSemanticsSchema,
@@ -782,6 +672,7 @@ export {
   gqlIdentityKey,
   graphqlOperationBinding,
   graphqlResolverBinding,
+  groundBinding,
   groundedPairingKey,
   hasNameHole,
   isGraphqlOperationBinding,
@@ -791,6 +682,7 @@ export {
   metricIdentityKey,
   namePatternFromSub,
   namePatternKey,
+  nameReference,
   namesAgree,
   namesBoundary,
   namesBoundaryExactly,

package/dist/schemas.cjs

@@ -358,6 +358,44 @@ var metricSemantics = defineBoundarySemantics({
 // src/semantics/rest.ts
 var import_zod6 = require("zod");
 
+// src/boundaryName.ts
+var HOLE_SPLIT = /(\{[^}]*\})/;
+function isHole(piece) {
+  return piece.startsWith("{") && piece.endsWith("}");
+}
+function parseBoundaryName(name) {
+  const parts = name.split(HOLE_SPLIT).filter((piece) => piece !== "").map(
+    (piece) => isHole(piece) ? { type: "hole", label: piece.slice(1, -1) } : { type: "text", text: piece }
+  );
+  const only = parts.length === 1 ? parts[0] : void 0;
+  if (only !== void 0 && only.type === "hole") {
+    return { type: "reference", path: only.label.split(".") };
+  }
+  if (parts.some((part) => part.type === "hole")) {
+    return { type: "pattern", parts };
+  }
+  return { type: "literal", value: name };
+}
+function patternHole(label) {
+  return `{${label}}`;
+}
+function namesNothing(name) {
+  return parseBoundaryName(name).type === "reference";
+}
+function referenceOf(name) {
+  if (name.type !== "reference") {
+    return null;
+  }
+  const root = name.path[0];
+  if (root === void 0 || name.path.some((part) => part === "")) {
+    return null;
+  }
+  return { root, fields: name.path.slice(1) };
+}
+function referenceFromName(name) {
+  return referenceOf(parseBoundaryName(name));
+}
+
 // src/urlPath.ts
 var SCHEME_ORIGIN = /^[a-zA-Z][a-zA-Z\d+.-]*:\/\/[^/]*/;
 var PROTOCOL_RELATIVE_ORIGIN = /^\/\/[^/]*/;
@@ -387,9 +425,9 @@ var RestSemanticsSchema = import_zod6.z.object({
   declaredResponses: import_zod6.z.array(import_zod6.z.number()).optional()
 });
 var OPENING_HOLE = /^\{([^{}]+)\}(.*)$/;
-function variableOf(label) {
-  const parts = label.split(".");
-  return parts[parts.length - 1] ?? label;
+function baseUrlReference(semantics) {
+  const label = OPENING_HOLE.exec(semantics.path ?? "")?.[1];
+  return label === void 0 ? null : referenceFromName(patternHole(label));
 }
 function normalizePath(path) {
   let normalized = path.replace(/:([a-zA-Z_]\w*)/g, "{$1}");
@@ -523,22 +561,20 @@ var restSemantics = defineBoundarySemantics({
      * route parameter, and `/orders/{id}` means every id rather than a
      * variable somebody set.
      */
-    groundName(semantics, deployedAs) {
-      if (semantics.path === null) {
+    groundName(semantics, deployment) {
+      const reference = baseUrlReference(semantics);
+      if (reference === null) {
         return null;
       }
-      const opening = OPENING_HOLE.exec(semantics.path);
-      if (opening === null) {
-        return null;
-      }
-      const [, label, rest] = opening;
-      const base = deployedAs(variableOf(label));
+      const base = deployment.setTo(reference);
       if (base === null) {
         return null;
       }
+      const rest = OPENING_HOLE.exec(semantics.path ?? "")?.[2] ?? "";
       const grounded = pathAfterOrigin(`${base}${rest}`);
       return { ...semantics, path: grounded === "" ? "/" : grounded };
     },
+    nameReference: baseUrlReference,
     ruleBoundary: {
       // "METHOD /path": one leading token, then an absolute path.
       claims(raw) {
@@ -625,6 +661,9 @@ var StorageSemanticsSchema = import_zod9.z.object({
    */
   accessPath: import_zod9.z.string().nullable()
 });
+function containerReference(semantics) {
+  return semantics.container === null ? null : referenceFromName(semantics.container);
+}
 var storageSemantics = defineBoundarySemantics({
   name: "storage",
   schema: StorageSemanticsSchema,
@@ -641,7 +680,21 @@ var storageSemantics = defineBoundarySemantics({
     exchangesHttpResponses: false,
     reportsUnpairedItself: false,
     identityKey: () => null,
-    displayLabel: storageLabel
+    displayLabel: storageLabel,
+    /**
+     * A container the source states as a variable is whatever the
+     * deployment sets that variable to. `{SUBSCRIBERS_TABLE}` in the
+     * code and `prod-subscribers-v1` in the manifest are one table.
+     */
+    groundName(semantics, deployment) {
+      const reference = containerReference(semantics);
+      if (reference === null) {
+        return null;
+      }
+      const name = deployment.setTo(reference);
+      return name === null ? null : { ...semantics, container: name };
+    },
+    nameReference: containerReference
   }
 });
 function storageLabel(semantics) {
@@ -659,6 +712,9 @@ var UnitInvocationSemanticsSchema = DeployableUnitSchema.extend({
   name: import_zod10.z.literal("unit-invocation"),
   instanceName: DeployableUnitSchema.shape.instanceName.nullable()
 });
+function calleeReference(semantics) {
+  return semantics.instanceName === null ? null : referenceFromName(semantics.instanceName);
+}
 var unitInvocationSemantics = defineBoundarySemantics({
   name: "unit-invocation",
   schema: UnitInvocationSemanticsSchema,
@@ -681,8 +737,13 @@ var unitInvocationSemantics = defineBoundarySemantics({
      * being reported as a problem here.
      */
     reportsUnpairedItself: false,
+    /**
+     * A callee the source states only as a variable is not a name for
+     * anything until the deployment fills it in, so it keys as nothing
+     * rather than as a bucket that would agree with itself alone.
+     */
     identityKey(semantics) {
-      if (semantics.instanceName === null) {
+      if (semantics.instanceName === null || namesNothing(semantics.instanceName)) {
         return null;
       }
       return unitIdentityKey(
@@ -698,7 +759,23 @@ var unitInvocationSemantics = defineBoundarySemantics({
         semantics.deploymentTarget,
         semantics.instanceName
       );
-    }
+    },
+    /**
+     * A call that reads its callee's name out of the environment
+     * reaches whichever resource the template wires that variable to.
+     * The logical id is the answer rather than the deployed name,
+     * because the invoked unit's own summary is keyed by the logical
+     * id and neither side ever writes the other's string.
+     */
+    groundName(semantics, deployment) {
+      const reference = calleeReference(semantics);
+      if (reference === null) {
+        return null;
+      }
+      const logicalId = deployment.pointsAt(reference);
+      return logicalId === null ? null : { ...semantics, instanceName: logicalId };
+    },
+    nameReference: calleeReference
   }
 });
 

package/dist/schemas.js

@@ -17,7 +17,7 @@ import {
   TypeShapeSchema,
   typeDefinitionKey,
   withDefinitionsInlined
-} from "./chunk-QHFMZPEG.js";
+} from "./chunk-PPQWK62O.js";
 export {
   BoundaryBindingSchema,
   ConfidenceInfoSchema,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@suss/ir-core",
-  "version": "0.21.0",
+  "version": "0.21.1",
   "type": "module",
   "description": "Shared IR primitives for suss — type shapes, boundary bindings, source locations, and confidence. Imported by both @suss/behavioral-ir and @suss/intent-ir so neither depends on the other.",
   "keywords": [