@suss/ir-core 0.5.8 → 0.5.10

package/dist/schemas-N9GyG0Sn.d.ts

@@ -0,0 +1,432 @@
+import { z } from 'zod';
+
+/**
+ * One thing that gets deployed and runs on its own: a Lambda function,
+ * an ECS task's container, a plain container, or a k8s deployment.
+ */
+
+/**
+ * `instanceName` is the stable identifier the deployment medium uses:
+ * the CFN logical resource id for Lambda and ECS, the deployment name
+ * for k8s, the container name for a plain container.
+ */
+declare const DeployableUnitSchema: z.ZodObject<{
+    deploymentTarget: z.ZodEnum<{
+        lambda: "lambda";
+        "ecs-task": "ecs-task";
+        container: "container";
+        "k8s-deployment": "k8s-deployment";
+    }>;
+    instanceName: z.ZodString;
+}, z.core.$strip>;
+type DeployableUnit = z.infer<typeof DeployableUnitSchema>;
+/**
+ * The `instanceName` for an ECS task's container: the task definition's
+ * own logical id, plus the container name from CFN's
+ * `ContainerDefinitions[*].Name`. Everyone who writes an ECS
+ * `DeployableUnit`, and everyone who matches a routing edge against
+ * one, has to put the two together the same way, so they all call this.
+ */
+declare function ecsContainerInstanceName(taskDefinitionLogicalId: string, containerName: string): string;
+
+declare const FunctionCallSemanticsSchema: z.ZodObject<{
+    name: z.ZodLiteral<"function-call">;
+    module: z.ZodOptional<z.ZodString>;
+    exportName: z.ZodOptional<z.ZodString>;
+    package: z.ZodOptional<z.ZodString>;
+    exportPath: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type FunctionCallSemantics = z.infer<typeof FunctionCallSemanticsSchema>;
+
+declare const GraphqlOperationSemanticsSchema: z.ZodObject<{
+    name: z.ZodLiteral<"graphql-operation">;
+    operationName: z.ZodOptional<z.ZodString>;
+    operationType: z.ZodEnum<{
+        query: "query";
+        mutation: "mutation";
+        subscription: "subscription";
+    }>;
+}, z.core.$strip>;
+type GraphqlOperationSemantics = z.infer<typeof GraphqlOperationSemanticsSchema>;
+
+declare const GraphqlResolverSemanticsSchema: z.ZodObject<{
+    name: z.ZodLiteral<"graphql-resolver">;
+    typeName: z.ZodNullable<z.ZodString>;
+    fieldName: z.ZodString;
+}, z.core.$strip>;
+type GraphqlResolverSemantics = z.infer<typeof GraphqlResolverSemanticsSchema>;
+
+declare const MessageBusSemanticsSchema: z.ZodObject<{
+    name: z.ZodLiteral<"message-bus">;
+    messageBus: z.ZodEnum<{
+        sqs: "sqs";
+        sns: "sns";
+        s3: "s3";
+        eventbridge: "eventbridge";
+        bullmq: "bullmq";
+        kafka: "kafka";
+        nats: "nats";
+    }>;
+    channel: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+type MessageBusSemantics = z.infer<typeof MessageBusSemanticsSchema>;
+/**
+ * The bus technologies the schema allows. It comes from the enum, so a
+ * value added there cannot drift from a hand-written copy elsewhere.
+ */
+type MessageBusTechnology = MessageBusSemantics["messageBus"];
+
+/**
+ * Where the protocol modules come together.
+ *
+ * Each protocol under this directory exports one
+ * `BoundarySemanticsDefinition`. This file lists them twice, once for
+ * the schema union and once for the behavior lookup, and the type check
+ * at the bottom fails compilation if the two lists ever cover different
+ * sets. Adding a protocol changes this file and no other, by one line in
+ * each list.
+ */
+
+/**
+ * The discriminated union every boundary binding validates against.
+ * Built from the protocol modules' own schemas.
+ */
+declare const SemanticsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    name: z.ZodLiteral<"rest">;
+    method: z.ZodNullable<z.ZodString>;
+    path: z.ZodNullable<z.ZodString>;
+    declaredResponses: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strip>, z.ZodObject<{
+    name: z.ZodLiteral<"function-call">;
+    module: z.ZodOptional<z.ZodString>;
+    exportName: z.ZodOptional<z.ZodString>;
+    package: z.ZodOptional<z.ZodString>;
+    exportPath: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    name: z.ZodLiteral<"graphql-resolver">;
+    typeName: z.ZodNullable<z.ZodString>;
+    fieldName: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    name: z.ZodLiteral<"graphql-operation">;
+    operationName: z.ZodOptional<z.ZodString>;
+    operationType: z.ZodEnum<{
+        query: "query";
+        mutation: "mutation";
+        subscription: "subscription";
+    }>;
+}, z.core.$strip>, z.ZodObject<{
+    deploymentTarget: z.ZodEnum<{
+        lambda: "lambda";
+        "ecs-task": "ecs-task";
+        container: "container";
+        "k8s-deployment": "k8s-deployment";
+    }>;
+    instanceName: z.ZodString;
+    name: z.ZodLiteral<"runtime-config">;
+}, z.core.$strip>, z.ZodObject<{
+    name: z.ZodLiteral<"storage-relational">;
+    storageSystem: z.ZodEnum<{
+        postgres: "postgres";
+        mysql: "mysql";
+        sqlite: "sqlite";
+    }>;
+    scope: z.ZodString;
+    table: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    name: z.ZodLiteral<"message-bus">;
+    messageBus: z.ZodEnum<{
+        sqs: "sqs";
+        sns: "sns";
+        s3: "s3";
+        eventbridge: "eventbridge";
+        bullmq: "bullmq";
+        kafka: "kafka";
+        nats: "nats";
+    }>;
+    channel: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>], "name">;
+type Semantics = z.infer<typeof SemanticsSchema>;
+
+declare const RestSemanticsSchema: z.ZodObject<{
+    name: z.ZodLiteral<"rest">;
+    method: z.ZodNullable<z.ZodString>;
+    path: z.ZodNullable<z.ZodString>;
+    declaredResponses: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strip>;
+type RestSemantics = z.infer<typeof RestSemanticsSchema>;
+/**
+ * Normalize a route path to a canonical form for matching.
+ *
+ * - Converts Express-style params (`:id`) to brace-style (`{id}`)
+ * - Strips trailing slashes (except bare `/`)
+ * - Lowercases the static segments (params stay case-sensitive)
+ */
+declare function normalizePath(path: string): string;
+/**
+ * Whether two REST methods mean the same thing. Equal methods agree,
+ * and `"*"` agrees with any stated method, because a handler that
+ * responds to every method responds to this one. A null method was never
+ * stated, so it agrees with nothing: there is no claim to agree with.
+ *
+ * This is the counterpart of `busesAgree`. No list of methods appears
+ * here, so a wildcard pairs with whatever methods consumers write.
+ */
+declare function methodsAgree(a: string | null, b: string | null): boolean;
+/** Whether a declared route path admits a concrete request path. */
+declare function routePathAdmits(declaredPath: string, requestPath: string): boolean;
+
+/**
+ * The pairing key is `(deploymentTarget, instanceName)`, which is
+ * exactly a deployable unit, so the two fields come from
+ * `DeployableUnitSchema` instead of being written out a second time.
+ */
+declare const RuntimeConfigSemanticsSchema: z.ZodObject<{
+    deploymentTarget: z.ZodEnum<{
+        lambda: "lambda";
+        "ecs-task": "ecs-task";
+        container: "container";
+        "k8s-deployment": "k8s-deployment";
+    }>;
+    instanceName: z.ZodString;
+    name: z.ZodLiteral<"runtime-config">;
+}, z.core.$strip>;
+type RuntimeConfigSemantics = z.infer<typeof RuntimeConfigSemanticsSchema>;
+
+declare const StorageRelationalSemanticsSchema: z.ZodObject<{
+    name: z.ZodLiteral<"storage-relational">;
+    storageSystem: z.ZodEnum<{
+        postgres: "postgres";
+        mysql: "mysql";
+        sqlite: "sqlite";
+    }>;
+    scope: z.ZodString;
+    table: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+type StorageRelationalSemantics = z.infer<typeof StorageRelationalSemanticsSchema>;
+
+/**
+ * @suss/ir-core schemas: primitives shared by every suss IR.
+ *
+ * These are the types that any IR built on suss references: the
+ * structure of a value (`TypeShape`), the identity of a boundary
+ * (`BoundaryBinding` and its `Semantics` variants), where something is
+ * in the source (`SourceLocation`), and how much to trust a claim
+ * (`Confidence`). Behavioural summaries, intent docs, and later on
+ * observation records all speak in these terms, so they are defined
+ * here, in one place none of those IRs needs another IR to reach.
+ *
+ * The schemas are the single source of truth, and the package's
+ * `index.ts` derives the types from them with `z.infer`.
+ */
+
+declare const ConfidenceSourceSchema: z.ZodEnum<{
+    inferred_static: "inferred_static";
+    inferred_ai: "inferred_ai";
+    declared: "declared";
+    derived: "derived";
+}>;
+declare const ConfidenceLevelSchema: z.ZodEnum<{
+    high: "high";
+    medium: "medium";
+    low: "low";
+}>;
+/**
+ * What came of corroborating a claim by running the code
+ * (`suss corroborate`). Inputs that satisfy the claim's own conditions
+ * are generated and run through the function, and the observation
+ * either agreed every time (`observed`), disagreed at least once
+ * (`refuted`, which is either an extractor bug or a surprise, and the
+ * counterexample says which input), or never produced a verdict
+ * (`untested`, meaning no satisfying input was found, or every
+ * satisfying run hit a dependency the harness cannot supply).
+ *
+ * Corroboration adds observations to a derivation. It is extra
+ * evidence, and it never rewrites the derived claim.
+ */
+declare const CorroborationSchema: z.ZodObject<{
+    outcome: z.ZodEnum<{
+        observed: "observed";
+        refuted: "refuted";
+        untested: "untested";
+    }>;
+    runs: z.ZodNumber;
+    counterexample: z.ZodOptional<z.ZodUnknown>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const ConfidenceInfoSchema: z.ZodObject<{
+    source: z.ZodEnum<{
+        inferred_static: "inferred_static";
+        inferred_ai: "inferred_ai";
+        declared: "declared";
+        derived: "derived";
+    }>;
+    level: z.ZodEnum<{
+        high: "high";
+        medium: "medium";
+        low: "low";
+    }>;
+    corroboration: z.ZodOptional<z.ZodObject<{
+        outcome: z.ZodEnum<{
+            observed: "observed";
+            refuted: "refuted";
+            untested: "untested";
+        }>;
+        runs: z.ZodNumber;
+        counterexample: z.ZodOptional<z.ZodUnknown>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const SourceLocationSchema: z.ZodObject<{
+    file: z.ZodString;
+    range: z.ZodObject<{
+        start: z.ZodNumber;
+        end: z.ZodNumber;
+    }, z.core.$strip>;
+    exportName: z.ZodNullable<z.ZodString>;
+    workspace: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const BoundaryBindingSchema: z.ZodObject<{
+    transport: z.ZodString;
+    semantics: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        name: z.ZodLiteral<"rest">;
+        method: z.ZodNullable<z.ZodString>;
+        path: z.ZodNullable<z.ZodString>;
+        declaredResponses: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    }, z.core.$strip>, z.ZodObject<{
+        name: z.ZodLiteral<"function-call">;
+        module: z.ZodOptional<z.ZodString>;
+        exportName: z.ZodOptional<z.ZodString>;
+        package: z.ZodOptional<z.ZodString>;
+        exportPath: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        name: z.ZodLiteral<"graphql-resolver">;
+        typeName: z.ZodNullable<z.ZodString>;
+        fieldName: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        name: z.ZodLiteral<"graphql-operation">;
+        operationName: z.ZodOptional<z.ZodString>;
+        operationType: z.ZodEnum<{
+            query: "query";
+            mutation: "mutation";
+            subscription: "subscription";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        deploymentTarget: z.ZodEnum<{
+            lambda: "lambda";
+            "ecs-task": "ecs-task";
+            container: "container";
+            "k8s-deployment": "k8s-deployment";
+        }>;
+        instanceName: z.ZodString;
+        name: z.ZodLiteral<"runtime-config">;
+    }, z.core.$strip>, z.ZodObject<{
+        name: z.ZodLiteral<"storage-relational">;
+        storageSystem: z.ZodEnum<{
+            postgres: "postgres";
+            mysql: "mysql";
+            sqlite: "sqlite";
+        }>;
+        scope: z.ZodString;
+        table: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        name: z.ZodLiteral<"message-bus">;
+        messageBus: z.ZodEnum<{
+            sqs: "sqs";
+            sns: "sns";
+            s3: "s3";
+            eventbridge: "eventbridge";
+            bullmq: "bullmq";
+            kafka: "kafka";
+            nats: "nats";
+        }>;
+        channel: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>], "name">;
+    recognition: z.ZodString;
+}, z.core.$strip>;
+type TypeShape = {
+    type: "record";
+    properties: Record<string, TypeShape>;
+    spreads?: Array<{
+        sourceText: string;
+    }> | undefined;
+} | {
+    type: "dictionary";
+    values: TypeShape;
+} | {
+    type: "array";
+    items: TypeShape;
+} | {
+    type: "literal";
+    value: string | number | boolean;
+    raw?: string | undefined;
+} | {
+    type: "text";
+} | {
+    type: "integer";
+} | {
+    type: "number";
+} | {
+    type: "boolean";
+} | {
+    type: "null";
+} | {
+    type: "undefined";
+} | {
+    type: "union";
+    variants: TypeShape[];
+} | {
+    type: "ref";
+    name: string;
+    /**
+     * Where this type is written down, when it is written down
+     * anywhere. It is the key into the summary's table of definitions.
+     *
+     * A name does not identify a type. Every instantiation of one
+     * generic reports the generic's own name and file, so `Omit<User,
+     * "secret">` and `Omit<Order, "total">` are both `Omit`, and a
+     * table keyed on that gives the second one the first one's fields.
+     * This key is built from what the type actually is.
+     */
+    def?: string | undefined;
+    /**
+     * The file that declares this type, when the project declares it.
+     * Absent for a name the language or a dependency owns, which means
+     * the same thing everywhere.
+     *
+     * A name on its own does not identify a type. Two modules each
+     * declaring a `User` produce the same ref, and a checker comparing
+     * them has nothing to go on. This is what tells them apart.
+     */
+    from?: string | undefined;
+} | {
+    type: "unknown";
+};
+/**
+ * The key a table of definitions uses for the type a ref points at.
+ *
+ * A ref has the name and the file that declares it, and that pair
+ * already identifies the type, so a table keyed on it needs nothing new
+ * on the ref. A name that the language or a dependency owns has no
+ * file, and keys on the name alone.
+ */
+declare function typeDefinitionKey(ref: {
+    def?: string | undefined;
+}): string | null;
+declare const TypeShapeSchema: z.ZodType<TypeShape>;
+/**
+ * A shape with the definitions it refers to substituted back into it.
+ *
+ * Comparing two shapes means comparing their structure, and a ref has
+ * none. Rather than teach every comparison to look in a table, the
+ * definitions go back into the shape once and everything downstream
+ * reads what it always read.
+ *
+ * Substituting a definition is not a level of nesting, so it does not
+ * spend depth. Counting it meant a type six deep came back three deep,
+ * and a consumer reading a field past that was told the provider did
+ * not have it. A type that refers to itself is stopped by the names
+ * already substituted on this path, the shape walk's own cycle guard.
+ */
+declare function withDefinitionsInlined(shape: TypeShape, definitions: Record<string, TypeShape> | undefined, depth?: number, inProgress?: ReadonlySet<string>): TypeShape;
+
+export { BoundaryBindingSchema as B, ConfidenceInfoSchema as C, type DeployableUnit as D, type FunctionCallSemantics as F, type GraphqlOperationSemantics as G, type MessageBusSemantics as M, type RestSemantics as R, type Semantics as S, type TypeShape as T, ConfidenceLevelSchema as a, ConfidenceSourceSchema as b, CorroborationSchema as c, SourceLocationSchema as d, type MessageBusTechnology as e, DeployableUnitSchema as f, FunctionCallSemanticsSchema as g, GraphqlOperationSemanticsSchema as h, type GraphqlResolverSemantics as i, GraphqlResolverSemanticsSchema as j, MessageBusSemanticsSchema as k, RestSemanticsSchema as l, type RuntimeConfigSemantics as m, RuntimeConfigSemanticsSchema as n, SemanticsSchema as o, type StorageRelationalSemantics as p, StorageRelationalSemanticsSchema as q, TypeShapeSchema as r, ecsContainerInstanceName as s, methodsAgree as t, normalizePath as u, routePathAdmits as v, typeDefinitionKey as w, withDefinitionsInlined as x };

package/dist/schemas.cjs

@@ -48,6 +48,17 @@ var import_zod9 = require("zod");
 // src/semantics/functionCall.ts
 var import_zod = require("zod");
 
+// src/identityKeys.ts
+function gqlIdentityKey(typeName, fieldName) {
+  return `gql:${typeName}.${fieldName}`;
+}
+function fnIdentityKey(packageName, exportPath) {
+  return `fn:${packageName}::${exportPath.join(".")}`;
+}
+function busIdentityKey(messageBus, subject) {
+  return `bus:${messageBus} ${subject}`;
+}
+
 // src/semantics/definition.ts
 function defineBoundarySemantics(definition) {
   return definition;
@@ -92,6 +103,12 @@ var functionCallSemantics = defineBoundarySemantics({
     /** A call returns a value, which is not a status and a body. */
     exchangesHttpResponses: false,
     reportsUnpairedItself: false,
+    /**
+     * In-repo units (components, bare handlers) are keyless by design
+     * and pair through call edges rather than the keyed pass, so a
+     * missing key is not a boundary nothing can reach.
+     */
+    canPair: () => true,
     /**
      * `"fn:<package>::<exportPath>"` when both are set. Other in-process
      * function-call units, such as components and bare handlers inside
@@ -99,7 +116,7 @@ var functionCallSemantics = defineBoundarySemantics({
      */
     identityKey(semantics) {
       if (semantics.package !== void 0 && semantics.exportPath !== void 0 && semantics.exportPath.length > 0) {
-        return `fn:${semantics.package}::${semantics.exportPath.join(".")}`;
+        return fnIdentityKey(semantics.package, semantics.exportPath);
       }
       return null;
     }
@@ -125,6 +142,8 @@ var graphqlOperationSemantics = defineBoundarySemantics({
     exchangesHttpResponses: false,
     reportsUnpairedItself: false,
     identityKey: () => null,
+    /** Keyless by design; the dedicated pass pairs it by its document. */
+    canPair: () => true,
     /** "query GetUser". The contract checker pairs it, the key does not. */
     displayLabel(semantics) {
       return `${semantics.operationType} ${semantics.operationName ?? "<anonymous>"}`;
@@ -161,7 +180,7 @@ var graphqlResolverSemantics = defineBoundarySemantics({
       if (semantics.typeName === null || semantics.fieldName === "") {
         return null;
       }
-      return `gql:${semantics.typeName}.${semantics.fieldName}`;
+      return gqlIdentityKey(semantics.typeName, semantics.fieldName);
     }
   }
 });
@@ -217,6 +236,12 @@ var messageBusSemantics = defineBoundarySemantics({
      * ones, so the generic unmatched lists leave them alone.
      */
     reportsUnpairedItself: true,
+    /**
+     * A channel unnamed here can still pair: the dedicated pass
+     * collapses env chains before comparing, so a consumer whose
+     * channel arrives at runtime meets the template that declares it.
+     */
+    canPair: () => true,
     /**
      * `"bus:<messageBus> <subject>"`, or null when the channel is null
      * or its subject is empty.
@@ -239,7 +264,7 @@ var messageBusSemantics = defineBoundarySemantics({
       if (subject === "") {
         return null;
       }
-      return `bus:${semantics.messageBus} ${subject}`;
+      return busIdentityKey(semantics.messageBus, subject);
     },
     sidesAgree(a, b) {
       if (a.channel === null || b.channel === null) {
@@ -431,8 +456,13 @@ var StorageRelationalSemanticsSchema = import_zod8.z.object({
    * and a monorepo with several schemas gives each one its own value.
    */
   scope: import_zod8.z.string(),
-  /** The table or model name, as declared in the schema. */
-  table: import_zod8.z.string()
+  /**
+   * The table or model name as the schema declares it, or null when
+   * the source states one this reader could not settle. A null table
+   * pairs with nothing, rather than with whatever its source text
+   * happens to spell.
+   */
+  table: import_zod8.z.string().nullable()
 });
 var storageRelationalSemantics = defineBoundarySemantics({
   name: "storage-relational",

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, e as DeployableUnitSchema, f as FunctionCallSemanticsSchema, g as GraphqlOperationSemanticsSchema, i as GraphqlResolverSemanticsSchema, k as MessageBusSemanticsSchema, l as RestSemanticsSchema, n as RuntimeConfigSemanticsSchema, o as SemanticsSchema, d as SourceLocationSchema, q as StorageRelationalSemanticsSchema, T as TypeShape, r as TypeShapeSchema, w as typeDefinitionKey, x as withDefinitionsInlined } from './schemas-BWvfkxSH.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 StorageRelationalSemanticsSchema, T as TypeShape, r as TypeShapeSchema, w as typeDefinitionKey, x as withDefinitionsInlined } from './schemas-N9GyG0Sn.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, e as DeployableUnitSchema, f as FunctionCallSemanticsSchema, g as GraphqlOperationSemanticsSchema, i as GraphqlResolverSemanticsSchema, k as MessageBusSemanticsSchema, l as RestSemanticsSchema, n as RuntimeConfigSemanticsSchema, o as SemanticsSchema, d as SourceLocationSchema, q as StorageRelationalSemanticsSchema, T as TypeShape, r as TypeShapeSchema, w as typeDefinitionKey, x as withDefinitionsInlined } from './schemas-BWvfkxSH.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 StorageRelationalSemanticsSchema, T as TypeShape, r as TypeShapeSchema, w as typeDefinitionKey, x as withDefinitionsInlined } from './schemas-N9GyG0Sn.js';

package/dist/schemas.js

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

package/package.json

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