@suss/ir-core 0.7.2 → 0.9.0

package/dist/schemas.cjs

@@ -40,10 +40,10 @@ __export(schemas_exports, {
   withDefinitionsInlined: () => withDefinitionsInlined
 });
 module.exports = __toCommonJS(schemas_exports);
-var import_zod10 = require("zod");
+var import_zod11 = require("zod");
 
 // src/semantics/registry.ts
-var import_zod9 = require("zod");
+var import_zod10 = 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 metricIdentityKey(metricSystem, metricType) {
+  return `metric:${metricSystem} ${metricType}`;
+}
 
 // src/semantics/definition.ts
 function defineBoundarySemantics(definition) {
@@ -99,6 +102,9 @@ var FunctionCallSemanticsSchema = import_zod.z.object({
 var functionCallSemantics = defineBoundarySemantics({
   name: "function-call",
   schema: FunctionCallSemanticsSchema,
+  // A call that never leaves the process does not produce a span, and
+  // the conventions do not name one. All of it is ours.
+  semconv: {},
   behavior: {
     /** A call returns a value, which is not a status and a body. */
     exchangesHttpResponses: false,
@@ -134,6 +140,10 @@ var GraphqlOperationSemanticsSchema = import_zod2.z.object({
 var graphqlOperationSemantics = defineBoundarySemantics({
   name: "graphql-operation",
   schema: GraphqlOperationSemanticsSchema,
+  semconv: {
+    operationName: { name: "graphql.operation.name" },
+    operationType: { name: "graphql.operation.type" }
+  },
   behavior: {
     /**
      * An operation gets a data-and-errors document back, which the
@@ -167,6 +177,9 @@ var GraphqlResolverSemanticsSchema = import_zod3.z.object({
 var graphqlResolverSemantics = defineBoundarySemantics({
   name: "graphql-resolver",
   schema: GraphqlResolverSemanticsSchema,
+  // The conventions name the operation a client sent, not the
+  // resolver the server ran for one field of it.
+  semconv: {},
   behavior: {
     /** A resolver returns a field value, not a status and a body. */
     exchangesHttpResponses: false,
@@ -209,13 +222,19 @@ function channelsPair(a, b) {
 var MessageBusSemanticsSchema = import_zod4.z.object({
   name: import_zod4.z.literal("message-bus"),
   messageBus: import_zod4.z.enum([
-    "sqs",
-    "sns",
+    // The conventions spell the two AWS buses this way, one with an
+    // underscore and one with a dot, so these are their strings and
+    // not a typo.
+    "aws_sqs",
+    "aws.sns",
     "s3",
     "eventbridge",
     "bullmq",
     "kafka",
-    "nats"
+    "nats",
+    "cloudflare-queues",
+    "cloudflare-cron",
+    "cloudflare-tail"
   ]),
   /**
    * Stable channel identifier: a CFN logical id, a queue or topic name,
@@ -228,6 +247,10 @@ var MessageBusSemanticsSchema = import_zod4.z.object({
 var messageBusSemantics = defineBoundarySemantics({
   name: "message-bus",
   schema: MessageBusSemanticsSchema,
+  semconv: {
+    messageBus: { name: "messaging.system" },
+    channel: { name: "messaging.destination.name" }
+  },
   behavior: {
     /** A message goes onto the channel and nothing comes back. */
     exchangesHttpResponses: false,
@@ -286,25 +309,58 @@ var messageBusSemantics = defineBoundarySemantics({
   }
 });
 
-// src/semantics/rest.ts
+// src/semantics/metric.ts
 var import_zod5 = require("zod");
-var RestSemanticsSchema = import_zod5.z.object({
-  name: import_zod5.z.literal("rest"),
+var MetricSemanticsSchema = import_zod5.z.object({
+  name: import_zod5.z.literal("metric"),
+  /** Which system the series lives in: cloud-monitoring, cloudwatch. */
+  metricSystem: import_zod5.z.string(),
+  /**
+   * The type string the system knows the metric by, spelled the way
+   * both sides spell it. Null when the source states one this reader
+   * could not settle, as with a query it could not read: a metric
+   * nobody could name pairs with nothing rather than with whatever
+   * happens to share its source text.
+   */
+  metricType: import_zod5.z.string().nullable()
+});
+var metricSemantics = defineBoundarySemantics({
+  name: "metric",
+  schema: MetricSemanticsSchema,
+  // OpenTelemetry knows a metric by its instrument name, and has no
+  // attribute for the system it lives in or the type string it goes by.
+  semconv: {},
+  behavior: {
+    exchangesHttpResponses: false,
+    reportsUnpairedItself: false,
+    identityKey(semantics) {
+      if (semantics.metricType === null) {
+        return null;
+      }
+      return metricIdentityKey(semantics.metricSystem, semantics.metricType);
+    }
+  }
+});
+
+// src/semantics/rest.ts
+var import_zod6 = require("zod");
+var RestSemanticsSchema = import_zod6.z.object({
+  name: import_zod6.z.literal("rest"),
   /**
    * Uppercase HTTP method ("GET", "POST", …), `"*"` for a handler that
    * responds to every method, or null when this source does not say
    * which method.
    */
-  method: import_zod5.z.string().min(1).nullable(),
+  method: import_zod6.z.string().min(1).nullable(),
   /** Normalized route path ("/users/{id}"), or null when this source does not give one. */
-  path: import_zod5.z.string().min(1).nullable(),
+  path: import_zod6.z.string().min(1).nullable(),
   /**
    * Status codes the producing source explicitly declared (OpenAPI
    * responses, CFN MethodResponses, ts-rest router statuses). They are
    * kept here so the pairing layer can see them without unwrapping any
    * metadata. Absent, or empty, for a source that was inferred.
    */
-  declaredResponses: import_zod5.z.array(import_zod5.z.number()).optional()
+  declaredResponses: import_zod6.z.array(import_zod6.z.number()).optional()
 });
 function normalizePath(path) {
   let normalized = path.replace(/:([a-zA-Z_]\w*)/g, "{$1}");
@@ -343,6 +399,14 @@ function routePathAdmits(declaredPath, requestPath) {
 var restSemantics = defineBoundarySemantics({
   name: "rest",
   schema: RestSemanticsSchema,
+  semconv: {
+    // A span states the one method a request used, so a route that
+    // responds to every method has nothing to compare.
+    method: { name: "http.request.method", placeholderValues: ["*"] },
+    path: { name: "http.route" }
+    // declaredResponses is a list, and http.response.status_code is
+    // the one status a request got back.
+  },
   behavior: {
     /** A request goes out, a status and a body come back. */
     exchangesHttpResponses: true,
@@ -415,29 +479,34 @@ var restSemantics = defineBoundarySemantics({
 });
 
 // src/semantics/runtimeConfig.ts
-var import_zod7 = require("zod");
+var import_zod8 = require("zod");
 
 // src/deployableUnit.ts
-var import_zod6 = require("zod");
-var DeployableUnitSchema = import_zod6.z.object({
-  deploymentTarget: import_zod6.z.enum([
+var import_zod7 = require("zod");
+var DeployableUnitSchema = import_zod7.z.object({
+  deploymentTarget: import_zod7.z.enum([
     "lambda",
     "ecs-task",
     "container",
-    "k8s-deployment"
+    "k8s-deployment",
+    "worker"
   ]),
   // An empty name would agree with every other empty name, so a unit
   // with no name has to leave the field off instead.
-  instanceName: import_zod6.z.string().min(1)
+  instanceName: import_zod7.z.string().min(1)
 });
 
 // src/semantics/runtimeConfig.ts
 var RuntimeConfigSemanticsSchema = DeployableUnitSchema.extend({
-  name: import_zod7.z.literal("runtime-config")
+  name: import_zod8.z.literal("runtime-config")
 });
 var runtimeConfigSemantics = defineBoundarySemantics({
   name: "runtime-config",
   schema: RuntimeConfigSemanticsSchema,
+  // service.name and cloud.resource_id name the same deployable, but
+  // instanceName is the deployment template's logical id, which is
+  // neither of those strings.
+  semconv: {},
   behavior: {
     /** A process reads its config at startup, and nothing replies. */
     exchangesHttpResponses: false,
@@ -447,28 +516,28 @@ var runtimeConfigSemantics = defineBoundarySemantics({
 });
 
 // src/semantics/storage.ts
-var import_zod8 = require("zod");
-var StorageSemanticsSchema = import_zod8.z.object({
-  name: import_zod8.z.literal("storage"),
+var import_zod9 = require("zod");
+var StorageSemanticsSchema = import_zod9.z.object({
+  name: import_zod9.z.literal("storage"),
   /**
-   * Which store this is: postgres, mysql, sqlite, dynamodb. Two
-   * products' containers can share a name, so this keeps them apart,
-   * and it is what a finding message calls the store.
+   * Which store this is: postgresql, mysql, aws.dynamodb, or our own
+   * word for one OpenTelemetry never named, such as s3. Two products'
+   * containers can share a name, so this keeps them apart.
    */
-  storageSystem: import_zod8.z.string(),
+  storageSystem: import_zod9.z.string(),
   /**
    * The ORM, schema, or deployment scope. A single-database setup uses
    * `"default"`, and a monorepo with several schemas gives each one its
    * own value.
    */
-  scope: import_zod8.z.string(),
+  scope: import_zod9.z.string(),
   /**
    * The table, bucket, collection, or index, as the source declares
    * it, or null when the source states one this reader could not
    * settle. A null container pairs with nothing, rather than with
    * whatever its source text happens to spell.
    */
-  container: import_zod8.z.string().nullable(),
+  container: import_zod9.z.string().nullable(),
   /**
    * A secondary way into the container, a DynamoDB global secondary
    * index or an Elasticsearch alias, each with its own key fields.
@@ -476,11 +545,19 @@ var StorageSemanticsSchema = import_zod8.z.object({
    * index and a query through the table are different accesses, so
    * they pair separately.
    */
-  accessPath: import_zod8.z.string().nullable()
+  accessPath: import_zod9.z.string().nullable()
 });
 var storageSemantics = defineBoundarySemantics({
   name: "storage",
   schema: StorageSemanticsSchema,
+  semconv: {
+    storageSystem: { name: "db.system.name" },
+    // "default" is our word for a source that named no database.
+    scope: { name: "db.namespace", placeholderValues: ["default"] },
+    container: { name: "db.collection.name" }
+    // A secondary index has no attribute of its own, so accessPath
+    // stays our word.
+  },
   behavior: {
     /** A query returns rows or items, not a status and a body. */
     exchangesHttpResponses: false,
@@ -490,14 +567,15 @@ var storageSemantics = defineBoundarySemantics({
 });
 
 // src/semantics/registry.ts
-var SemanticsSchema = import_zod9.z.discriminatedUnion("name", [
+var SemanticsSchema = import_zod10.z.discriminatedUnion("name", [
   restSemantics.schema,
   functionCallSemantics.schema,
   graphqlResolverSemantics.schema,
   graphqlOperationSemantics.schema,
   runtimeConfigSemantics.schema,
   storageSemantics.schema,
-  messageBusSemantics.schema
+  messageBusSemantics.schema,
+  metricSemantics.schema
 ]);
 var DEFINITIONS = [
   restSemantics,
@@ -506,38 +584,39 @@ var DEFINITIONS = [
   graphqlOperationSemantics,
   runtimeConfigSemantics,
   storageSemantics,
-  messageBusSemantics
+  messageBusSemantics,
+  metricSemantics
 ];
 var BY_NAME = new Map(
   DEFINITIONS.map((d) => [d.name, d])
 );
 
 // src/schemas.ts
-var ConfidenceSourceSchema = import_zod10.z.enum([
+var ConfidenceSourceSchema = import_zod11.z.enum([
   "inferred_static",
   "inferred_ai",
   "declared",
   "derived"
 ]);
-var ConfidenceLevelSchema = import_zod10.z.enum(["high", "medium", "low"]);
-var CorroborationSchema = import_zod10.z.object({
-  outcome: import_zod10.z.enum(["observed", "refuted", "untested"]),
+var ConfidenceLevelSchema = import_zod11.z.enum(["high", "medium", "low"]);
+var CorroborationSchema = import_zod11.z.object({
+  outcome: import_zod11.z.enum(["observed", "refuted", "untested"]),
   /** Executions that produced a verdict for this claim. */
-  runs: import_zod10.z.number(),
+  runs: import_zod11.z.number(),
   /** Present when refuted: the input and observation that disagreed. */
-  counterexample: import_zod10.z.unknown().optional(),
+  counterexample: import_zod11.z.unknown().optional(),
   /** Present when untested: why no verdict was reachable. */
-  reason: import_zod10.z.string().optional()
+  reason: import_zod11.z.string().optional()
 });
-var ConfidenceInfoSchema = import_zod10.z.object({
+var ConfidenceInfoSchema = import_zod11.z.object({
   source: ConfidenceSourceSchema,
   level: ConfidenceLevelSchema,
   corroboration: CorroborationSchema.optional()
 });
-var SourceLocationSchema = import_zod10.z.object({
-  file: import_zod10.z.string(),
-  range: import_zod10.z.object({ start: import_zod10.z.number(), end: import_zod10.z.number() }),
-  exportName: import_zod10.z.string().nullable(),
+var SourceLocationSchema = import_zod11.z.object({
+  file: import_zod11.z.string(),
+  range: import_zod11.z.object({ start: import_zod11.z.number(), end: import_zod11.z.number() }),
+  exportName: import_zod11.z.string().nullable(),
   /**
    * The project the extract was pointed at, by the name that project
    * calls itself.
@@ -547,47 +626,47 @@ var SourceLocationSchema = import_zod10.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_zod10.z.string().optional()
+  workspace: import_zod11.z.string().optional()
 });
-var BoundaryBindingSchema = import_zod10.z.object({
-  transport: import_zod10.z.string(),
+var BoundaryBindingSchema = import_zod11.z.object({
+  transport: import_zod11.z.string(),
   semantics: SemanticsSchema,
-  recognition: import_zod10.z.string()
+  recognition: import_zod11.z.string()
 });
 function typeDefinitionKey(ref) {
   return ref.def ?? null;
 }
-var TypeShapeSchema = import_zod10.z.lazy(
-  () => import_zod10.z.discriminatedUnion("type", [
-    import_zod10.z.object({
-      type: import_zod10.z.literal("record"),
-      properties: import_zod10.z.record(import_zod10.z.string(), TypeShapeSchema),
-      spreads: import_zod10.z.array(import_zod10.z.object({ sourceText: import_zod10.z.string() })).optional()
+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()
     }),
-    import_zod10.z.object({ type: import_zod10.z.literal("dictionary"), values: TypeShapeSchema }),
-    import_zod10.z.object({ type: import_zod10.z.literal("array"), items: TypeShapeSchema }),
-    import_zod10.z.object({
-      type: import_zod10.z.literal("literal"),
-      value: import_zod10.z.union([import_zod10.z.string(), import_zod10.z.number(), import_zod10.z.boolean()]),
-      raw: import_zod10.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_zod10.z.object({ type: import_zod10.z.literal("text") }),
-    import_zod10.z.object({ type: import_zod10.z.literal("integer") }),
-    import_zod10.z.object({ type: import_zod10.z.literal("number") }),
-    import_zod10.z.object({ type: import_zod10.z.literal("boolean") }),
-    import_zod10.z.object({ type: import_zod10.z.literal("null") }),
-    import_zod10.z.object({ type: import_zod10.z.literal("undefined") }),
-    import_zod10.z.object({
-      type: import_zod10.z.literal("union"),
-      variants: import_zod10.z.array(TypeShapeSchema)
+    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_zod10.z.object({
-      type: import_zod10.z.literal("ref"),
-      name: import_zod10.z.string(),
-      from: import_zod10.z.string().optional(),
-      def: import_zod10.z.string().optional()
+    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_zod10.z.object({ type: import_zod10.z.literal("unknown") })
+    import_zod11.z.object({ type: import_zod11.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, w as typeDefinitionKey, x as withDefinitionsInlined } from './schemas-D6hKT-zV.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, w as typeDefinitionKey, x as withDefinitionsInlined } from './schemas-CGR6qjFf.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, w as typeDefinitionKey, x as withDefinitionsInlined } from './schemas-D6hKT-zV.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, w as typeDefinitionKey, x as withDefinitionsInlined } from './schemas-CGR6qjFf.js';

package/dist/schemas.js

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

package/package.json

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