@suss/ir-core 0.20.0 → 0.21.1

package/dist/schemas.cjs

@@ -40,10 +40,10 @@ __export(schemas_exports, {
   withDefinitionsInlined: () => withDefinitionsInlined
 });
 module.exports = __toCommonJS(schemas_exports);
-var import_zod11 = require("zod");
+var import_zod12 = require("zod");
 
 // src/semantics/registry.ts
-var import_zod10 = require("zod");
+var import_zod11 = require("zod");
 
 // src/semantics/functionCall.ts
 var import_zod = require("zod");
@@ -58,6 +58,9 @@ function fnIdentityKey(packageName, exportPath) {
 function busIdentityKey(messageBus, subject) {
   return `bus:${messageBus} ${subject}`;
 }
+function unitIdentityKey(deploymentTarget, instanceName) {
+  return `unit:${deploymentTarget} ${instanceName}`;
+}
 function metricIdentityKey(metricSystem, metricType) {
   return `metric:${metricSystem} ${metricType}`;
 }
@@ -355,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 = /^\/\/[^/]*/;
@@ -384,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}");
@@ -497,6 +538,14 @@ var restSemantics = defineBoundarySemantics({
       }
       return routePathAdmits(semantics.path, path) ? "match" : "nomatch";
     },
+    /**
+     * A route the registration pattern admits is inside it. A route
+     * whose path this source never gave is left outside, because
+     * nothing here can show it is one the pattern covers.
+     */
+    withinScope(semantics, scope) {
+      return semantics.path !== null && routePathAdmits(scope, semantics.path);
+    },
     /**
      * A call whose base URL the deployment fills in, resolved to the
      * path it reaches.
@@ -512,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) {
@@ -614,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,
@@ -629,12 +679,108 @@ var storageSemantics = defineBoundarySemantics({
     /** A query returns rows or items, not a status and a body. */
     exchangesHttpResponses: false,
     reportsUnpairedItself: false,
-    identityKey: () => null
+    identityKey: () => null,
+    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) {
+  return `${semantics.storageSystem}:${storageContainerLabel(semantics)}`;
+}
+function storageContainerLabel(semantics) {
+  const container = semantics.container ?? "<unnamed container>";
+  const addressed = semantics.accessPath === null ? container : `${container}#${semantics.accessPath}`;
+  return semantics.scope === "default" ? addressed : `${semantics.scope}/${addressed}`;
+}
+
+// src/semantics/unitInvocation.ts
+var import_zod10 = require("zod");
+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,
+  // faas.name is the deployed function's own name and instanceName is
+  // the deployment template's logical id, which is a different string.
+  // Runtime config leaves the pair off for the same reason.
+  semconv: {},
+  behavior: {
+    /**
+     * A synchronous invoke gives back whatever the handler returned,
+     * which is a value rather than a status and a body. A handler's
+     * return only becomes an HTTP response under a proxy integration,
+     * and that route gets a REST binding instead of this one.
+     */
+    exchangesHttpResponses: false,
+    /**
+     * A unit nothing in the run invokes is the ordinary case, since
+     * most services are reached from a stack suss never read. So an
+     * uninvoked unit stays in the generic unmatched list rather than
+     * 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 || namesNothing(semantics.instanceName)) {
+        return null;
+      }
+      return unitIdentityKey(
+        semantics.deploymentTarget,
+        semantics.instanceName
+      );
+    },
+    displayLabel(semantics) {
+      if (semantics.instanceName === null) {
+        return `unit:${semantics.deploymentTarget} (named at runtime)`;
+      }
+      return unitIdentityKey(
+        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
   }
 });
 
 // src/semantics/registry.ts
-var SemanticsSchema = import_zod10.z.discriminatedUnion("name", [
+var SemanticsSchema = import_zod11.z.discriminatedUnion("name", [
   restSemantics.schema,
   functionCallSemantics.schema,
   graphqlResolverSemantics.schema,
@@ -642,7 +788,8 @@ var SemanticsSchema = import_zod10.z.discriminatedUnion("name", [
   runtimeConfigSemantics.schema,
   storageSemantics.schema,
   messageBusSemantics.schema,
-  metricSemantics.schema
+  metricSemantics.schema,
+  unitInvocationSemantics.schema
 ]);
 var DEFINITIONS = [
   restSemantics,
@@ -652,38 +799,39 @@ var DEFINITIONS = [
   runtimeConfigSemantics,
   storageSemantics,
   messageBusSemantics,
-  metricSemantics
+  metricSemantics,
+  unitInvocationSemantics
 ];
 var BY_NAME = new Map(
   DEFINITIONS.map((d) => [d.name, d])
 );
 
 // src/schemas.ts
-var ConfidenceSourceSchema = import_zod11.z.enum([
+var ConfidenceSourceSchema = import_zod12.z.enum([
   "inferred_static",
   "inferred_ai",
   "declared",
   "derived"
 ]);
-var ConfidenceLevelSchema = import_zod11.z.enum(["high", "medium", "low"]);
-var CorroborationSchema = import_zod11.z.object({
-  outcome: import_zod11.z.enum(["observed", "refuted", "untested"]),
+var ConfidenceLevelSchema = import_zod12.z.enum(["high", "medium", "low"]);
+var CorroborationSchema = import_zod12.z.object({
+  outcome: import_zod12.z.enum(["observed", "refuted", "untested"]),
   /** Executions that produced a verdict for this claim. */
-  runs: import_zod11.z.number(),
+  runs: import_zod12.z.number(),
   /** Present when refuted: the input and observation that disagreed. */
-  counterexample: import_zod11.z.unknown().optional(),
+  counterexample: import_zod12.z.unknown().optional(),
   /** Present when untested: why no verdict was reachable. */
-  reason: import_zod11.z.string().optional()
+  reason: import_zod12.z.string().optional()
 });
-var ConfidenceInfoSchema = import_zod11.z.object({
+var ConfidenceInfoSchema = import_zod12.z.object({
   source: ConfidenceSourceSchema,
   level: ConfidenceLevelSchema,
   corroboration: CorroborationSchema.optional()
 });
-var SourceLocationSchema = import_zod11.z.object({
-  file: import_zod11.z.string(),
+var SourceLocationSchema = import_zod12.z.object({
+  file: import_zod12.z.string(),
   /** Line numbers, for a person reading the summary or an editor link. */
-  range: import_zod11.z.object({ start: import_zod11.z.number(), end: import_zod11.z.number() }),
+  range: import_zod12.z.object({ start: import_zod12.z.number(), end: import_zod12.z.number() }),
   /**
    * Character offsets of the unit in its file. Identity and joins
    * measure with these, since two functions can share a line and never
@@ -691,8 +839,8 @@ var SourceLocationSchema = import_zod11.z.object({
    * same place. Absent on summaries no source position backs, a
    * contract artifact's say.
    */
-  span: import_zod11.z.object({ start: import_zod11.z.number(), end: import_zod11.z.number() }).optional(),
-  exportName: import_zod11.z.string().nullable(),
+  span: import_zod12.z.object({ start: import_zod12.z.number(), end: import_zod12.z.number() }).optional(),
+  exportName: import_zod12.z.string().nullable(),
   /**
    * The project the extract was pointed at, by the name that project
    * calls itself.
@@ -702,47 +850,47 @@ var SourceLocationSchema = import_zod11.z.object({
    * summaries puts them on top of each other. This field is what tells
    * them apart, and what a reader groups by.
    */
-  workspace: import_zod11.z.string().optional()
+  workspace: import_zod12.z.string().optional()
 });
-var BoundaryBindingSchema = import_zod11.z.object({
-  transport: import_zod11.z.string(),
+var BoundaryBindingSchema = import_zod12.z.object({
+  transport: import_zod12.z.string(),
   semantics: SemanticsSchema,
-  recognition: import_zod11.z.string()
+  recognition: import_zod12.z.string()
 });
 function typeDefinitionKey(ref) {
   return ref.def ?? null;
 }
-var TypeShapeSchema = import_zod11.z.lazy(
-  () => import_zod11.z.discriminatedUnion("type", [
-    import_zod11.z.object({
-      type: import_zod11.z.literal("record"),
-      properties: import_zod11.z.record(import_zod11.z.string(), TypeShapeSchema),
-      spreads: import_zod11.z.array(import_zod11.z.object({ sourceText: import_zod11.z.string() })).optional()
+var TypeShapeSchema = import_zod12.z.lazy(
+  () => import_zod12.z.discriminatedUnion("type", [
+    import_zod12.z.object({
+      type: import_zod12.z.literal("record"),
+      properties: import_zod12.z.record(import_zod12.z.string(), TypeShapeSchema),
+      spreads: import_zod12.z.array(import_zod12.z.object({ sourceText: import_zod12.z.string() })).optional()
     }),
-    import_zod11.z.object({ type: import_zod11.z.literal("dictionary"), values: TypeShapeSchema }),
-    import_zod11.z.object({ type: import_zod11.z.literal("array"), items: TypeShapeSchema }),
-    import_zod11.z.object({
-      type: import_zod11.z.literal("literal"),
-      value: import_zod11.z.union([import_zod11.z.string(), import_zod11.z.number(), import_zod11.z.boolean()]),
-      raw: import_zod11.z.string().optional()
+    import_zod12.z.object({ type: import_zod12.z.literal("dictionary"), values: TypeShapeSchema }),
+    import_zod12.z.object({ type: import_zod12.z.literal("array"), items: TypeShapeSchema }),
+    import_zod12.z.object({
+      type: import_zod12.z.literal("literal"),
+      value: import_zod12.z.union([import_zod12.z.string(), import_zod12.z.number(), import_zod12.z.boolean()]),
+      raw: import_zod12.z.string().optional()
     }),
-    import_zod11.z.object({ type: import_zod11.z.literal("text") }),
-    import_zod11.z.object({ type: import_zod11.z.literal("integer") }),
-    import_zod11.z.object({ type: import_zod11.z.literal("number") }),
-    import_zod11.z.object({ type: import_zod11.z.literal("boolean") }),
-    import_zod11.z.object({ type: import_zod11.z.literal("null") }),
-    import_zod11.z.object({ type: import_zod11.z.literal("undefined") }),
-    import_zod11.z.object({
-      type: import_zod11.z.literal("union"),
-      variants: import_zod11.z.array(TypeShapeSchema)
+    import_zod12.z.object({ type: import_zod12.z.literal("text") }),
+    import_zod12.z.object({ type: import_zod12.z.literal("integer") }),
+    import_zod12.z.object({ type: import_zod12.z.literal("number") }),
+    import_zod12.z.object({ type: import_zod12.z.literal("boolean") }),
+    import_zod12.z.object({ type: import_zod12.z.literal("null") }),
+    import_zod12.z.object({ type: import_zod12.z.literal("undefined") }),
+    import_zod12.z.object({
+      type: import_zod12.z.literal("union"),
+      variants: import_zod12.z.array(TypeShapeSchema)
     }),
-    import_zod11.z.object({
-      type: import_zod11.z.literal("ref"),
-      name: import_zod11.z.string(),
-      from: import_zod11.z.string().optional(),
-      def: import_zod11.z.string().optional()
+    import_zod12.z.object({
+      type: import_zod12.z.literal("ref"),
+      name: import_zod12.z.string(),
+      from: import_zod12.z.string().optional(),
+      def: import_zod12.z.string().optional()
     }),
-    import_zod11.z.object({ type: import_zod11.z.literal("unknown") })
+    import_zod12.z.object({ type: import_zod12.z.literal("unknown") })
   ])
 );
 var MAX_DEFINITION_DEPTH = 6;

package/dist/schemas.d.cts

@@ -1,2 +1,2 @@
 import 'zod';
-export { B as BoundaryBindingSchema, C as ConfidenceInfoSchema, a as ConfidenceLevelSchema, b as ConfidenceSourceSchema, c as CorroborationSchema, f as DeployableUnitSchema, g as FunctionCallSemanticsSchema, h as GraphqlOperationSemanticsSchema, j as GraphqlResolverSemanticsSchema, k as MessageBusSemanticsSchema, l as RestSemanticsSchema, n as RuntimeConfigSemanticsSchema, o as SemanticsSchema, d as SourceLocationSchema, q as StorageSemanticsSchema, T as TypeShape, r as TypeShapeSchema, x as typeDefinitionKey, y as withDefinitionsInlined } from './schemas-Dt93kAZT.cjs';
+export { B as BoundaryBindingSchema, C as ConfidenceInfoSchema, a as ConfidenceLevelSchema, b as ConfidenceSourceSchema, c as CorroborationSchema, f as DeployableUnitSchema, g as FunctionCallSemanticsSchema, h as GraphqlOperationSemanticsSchema, j as GraphqlResolverSemanticsSchema, k as MessageBusSemanticsSchema, l as RestSemanticsSchema, n as RuntimeConfigSemanticsSchema, o as SemanticsSchema, d as SourceLocationSchema, q as StorageSemanticsSchema, T as TypeShape, r as TypeShapeSchema, z as typeDefinitionKey, A as withDefinitionsInlined } from './schemas-Dn1AzzWd.cjs';

package/dist/schemas.d.ts

@@ -1,2 +1,2 @@
 import 'zod';
-export { B as BoundaryBindingSchema, C as ConfidenceInfoSchema, a as ConfidenceLevelSchema, b as ConfidenceSourceSchema, c as CorroborationSchema, f as DeployableUnitSchema, g as FunctionCallSemanticsSchema, h as GraphqlOperationSemanticsSchema, j as GraphqlResolverSemanticsSchema, k as MessageBusSemanticsSchema, l as RestSemanticsSchema, n as RuntimeConfigSemanticsSchema, o as SemanticsSchema, d as SourceLocationSchema, q as StorageSemanticsSchema, T as TypeShape, r as TypeShapeSchema, x as typeDefinitionKey, y as withDefinitionsInlined } from './schemas-Dt93kAZT.js';
+export { B as BoundaryBindingSchema, C as ConfidenceInfoSchema, a as ConfidenceLevelSchema, b as ConfidenceSourceSchema, c as CorroborationSchema, f as DeployableUnitSchema, g as FunctionCallSemanticsSchema, h as GraphqlOperationSemanticsSchema, j as GraphqlResolverSemanticsSchema, k as MessageBusSemanticsSchema, l as RestSemanticsSchema, n as RuntimeConfigSemanticsSchema, o as SemanticsSchema, d as SourceLocationSchema, q as StorageSemanticsSchema, T as TypeShape, r as TypeShapeSchema, z as typeDefinitionKey, A as withDefinitionsInlined } from './schemas-Dn1AzzWd.js';

package/dist/schemas.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@suss/ir-core",
-  "version": "0.20.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": [