@suss/ir-core 0.19.0 → 0.21.0

package/dist/{chunk-HSJYPBJU.js → chunk-QHFMZPEG.js}

@@ -1,8 +1,8 @@
 // src/schemas.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 
 // src/semantics/registry.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 
 // src/semantics/functionCall.ts
 import { z } from "zod";
@@ -17,6 +17,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}`;
 }
@@ -75,14 +78,24 @@ var functionCallSemantics = defineBoundarySemantics({
      */
     canPair: () => true,
     /**
-     * `"fn:<package>::<exportPath>"` when both are set. Other in-process
-     * function-call units, such as components and bare handlers inside
-     * one repo, have no key at all.
+     * `"fn:<package>::<exportPath>"` when both are set, and
+     * `"fn:<module>::<exportName>"` for an in-repo unit that states its
+     * module, the way a server action does. Components and bare
+     * handlers state neither and have no key at all.
      */
+    rewritePaths(semantics, rewrite) {
+      if (semantics.module === void 0) {
+        return semantics;
+      }
+      return { ...semantics, module: rewrite(semantics.module) };
+    },
     identityKey(semantics) {
       if (semantics.package !== void 0 && semantics.exportPath !== void 0 && semantics.exportPath.length > 0) {
         return fnIdentityKey(semantics.package, semantics.exportPath);
       }
+      if (semantics.module !== void 0 && semantics.exportName !== void 0) {
+        return fnIdentityKey(semantics.module, [semantics.exportName]);
+      }
       return null;
     }
   }
@@ -455,6 +468,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.
@@ -590,12 +611,71 @@ 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
+  }
+});
+function storageLabel(semantics) {
+  return `${semantics.storageSystem}:${storageContainerLabel(semantics)}`;
+}
+var EVERY_FIELD = "*";
+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
+import { z as z10 } from "zod";
+var UnitInvocationSemanticsSchema = DeployableUnitSchema.extend({
+  name: z10.literal("unit-invocation"),
+  instanceName: DeployableUnitSchema.shape.instanceName.nullable()
+});
+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,
+    identityKey(semantics) {
+      if (semantics.instanceName === null) {
+        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
+      );
+    }
   }
 });
 
 // src/semantics/registry.ts
-var SemanticsSchema = z10.discriminatedUnion("name", [
+var SemanticsSchema = z11.discriminatedUnion("name", [
   restSemantics.schema,
   functionCallSemantics.schema,
   graphqlResolverSemantics.schema,
@@ -603,7 +683,8 @@ var SemanticsSchema = z10.discriminatedUnion("name", [
   runtimeConfigSemantics.schema,
   storageSemantics.schema,
   messageBusSemantics.schema,
-  metricSemantics.schema
+  metricSemantics.schema,
+  unitInvocationSemantics.schema
 ]);
 var DEFINITIONS = [
   restSemantics,
@@ -613,7 +694,8 @@ var DEFINITIONS = [
   runtimeConfigSemantics,
   storageSemantics,
   messageBusSemantics,
-  metricSemantics
+  metricSemantics,
+  unitInvocationSemantics
 ];
 var BY_NAME = new Map(
   DEFINITIONS.map((d) => [d.name, d])
@@ -636,31 +718,40 @@ function allBehaviors() {
 }
 
 // src/schemas.ts
-var ConfidenceSourceSchema = z11.enum([
+var ConfidenceSourceSchema = z12.enum([
   "inferred_static",
   "inferred_ai",
   "declared",
   "derived"
 ]);
-var ConfidenceLevelSchema = z11.enum(["high", "medium", "low"]);
-var CorroborationSchema = z11.object({
-  outcome: z11.enum(["observed", "refuted", "untested"]),
+var ConfidenceLevelSchema = z12.enum(["high", "medium", "low"]);
+var CorroborationSchema = z12.object({
+  outcome: z12.enum(["observed", "refuted", "untested"]),
   /** Executions that produced a verdict for this claim. */
-  runs: z11.number(),
+  runs: z12.number(),
   /** Present when refuted: the input and observation that disagreed. */
-  counterexample: z11.unknown().optional(),
+  counterexample: z12.unknown().optional(),
   /** Present when untested: why no verdict was reachable. */
-  reason: z11.string().optional()
+  reason: z12.string().optional()
 });
-var ConfidenceInfoSchema = z11.object({
+var ConfidenceInfoSchema = z12.object({
   source: ConfidenceSourceSchema,
   level: ConfidenceLevelSchema,
   corroboration: CorroborationSchema.optional()
 });
-var SourceLocationSchema = z11.object({
-  file: z11.string(),
-  range: z11.object({ start: z11.number(), end: z11.number() }),
-  exportName: z11.string().nullable(),
+var SourceLocationSchema = z12.object({
+  file: z12.string(),
+  /** Line numbers, for a person reading the summary or an editor link. */
+  range: z12.object({ start: z12.number(), end: z12.number() }),
+  /**
+   * Character offsets of the unit in its file. Identity and joins
+   * measure with these, since two functions can share a line and never
+   * an offset range; the line `range` above is the presentation of the
+   * same place. Absent on summaries no source position backs, a
+   * contract artifact's say.
+   */
+  span: z12.object({ start: z12.number(), end: z12.number() }).optional(),
+  exportName: z12.string().nullable(),
   /**
    * The project the extract was pointed at, by the name that project
    * calls itself.
@@ -670,47 +761,47 @@ var SourceLocationSchema = z11.object({
    * summaries puts them on top of each other. This field is what tells
    * them apart, and what a reader groups by.
    */
-  workspace: z11.string().optional()
+  workspace: z12.string().optional()
 });
-var BoundaryBindingSchema = z11.object({
-  transport: z11.string(),
+var BoundaryBindingSchema = z12.object({
+  transport: z12.string(),
   semantics: SemanticsSchema,
-  recognition: z11.string()
+  recognition: z12.string()
 });
 function typeDefinitionKey(ref) {
   return ref.def ?? null;
 }
-var TypeShapeSchema = z11.lazy(
-  () => z11.discriminatedUnion("type", [
-    z11.object({
-      type: z11.literal("record"),
-      properties: z11.record(z11.string(), TypeShapeSchema),
-      spreads: z11.array(z11.object({ sourceText: z11.string() })).optional()
+var TypeShapeSchema = z12.lazy(
+  () => z12.discriminatedUnion("type", [
+    z12.object({
+      type: z12.literal("record"),
+      properties: z12.record(z12.string(), TypeShapeSchema),
+      spreads: z12.array(z12.object({ sourceText: z12.string() })).optional()
     }),
-    z11.object({ type: z11.literal("dictionary"), values: TypeShapeSchema }),
-    z11.object({ type: z11.literal("array"), items: TypeShapeSchema }),
-    z11.object({
-      type: z11.literal("literal"),
-      value: z11.union([z11.string(), z11.number(), z11.boolean()]),
-      raw: z11.string().optional()
+    z12.object({ type: z12.literal("dictionary"), values: TypeShapeSchema }),
+    z12.object({ type: z12.literal("array"), items: TypeShapeSchema }),
+    z12.object({
+      type: z12.literal("literal"),
+      value: z12.union([z12.string(), z12.number(), z12.boolean()]),
+      raw: z12.string().optional()
     }),
-    z11.object({ type: z11.literal("text") }),
-    z11.object({ type: z11.literal("integer") }),
-    z11.object({ type: z11.literal("number") }),
-    z11.object({ type: z11.literal("boolean") }),
-    z11.object({ type: z11.literal("null") }),
-    z11.object({ type: z11.literal("undefined") }),
-    z11.object({
-      type: z11.literal("union"),
-      variants: z11.array(TypeShapeSchema)
+    z12.object({ type: z12.literal("text") }),
+    z12.object({ type: z12.literal("integer") }),
+    z12.object({ type: z12.literal("number") }),
+    z12.object({ type: z12.literal("boolean") }),
+    z12.object({ type: z12.literal("null") }),
+    z12.object({ type: z12.literal("undefined") }),
+    z12.object({
+      type: z12.literal("union"),
+      variants: z12.array(TypeShapeSchema)
     }),
-    z11.object({
-      type: z11.literal("ref"),
-      name: z11.string(),
-      from: z11.string().optional(),
-      def: z11.string().optional()
+    z12.object({
+      type: z12.literal("ref"),
+      name: z12.string(),
+      from: z12.string().optional(),
+      def: z12.string().optional()
     }),
-    z11.object({ type: z11.literal("unknown") })
+    z12.object({ type: z12.literal("unknown") })
   ])
 );
 var MAX_DEFINITION_DEPTH = 6;
@@ -759,6 +850,7 @@ export {
   gqlIdentityKey,
   fnIdentityKey,
   busIdentityKey,
+  unitIdentityKey,
   metricIdentityKey,
   FunctionCallSemanticsSchema,
   GraphqlResolverSemanticsSchema,
@@ -779,6 +871,10 @@ export {
   ecsContainerInstanceName,
   RuntimeConfigSemanticsSchema,
   StorageSemanticsSchema,
+  storageLabel,
+  EVERY_FIELD,
+  storageContainerLabel,
+  UnitInvocationSemanticsSchema,
   SemanticsSchema,
   behaviorOf,
   semconvMappingOf,