@suss/ir-core 0.1.1 → 0.3.0

package/dist/{chunk-QQLJDL3C.js → chunk-L4XGOS3I.js}

@@ -24,7 +24,16 @@ var ConfidenceInfoSchema = z.object({
 var SourceLocationSchema = z.object({
   file: z.string(),
   range: z.object({ start: z.number(), end: z.number() }),
-  exportName: z.string().nullable()
+  exportName: z.string().nullable(),
+  /**
+   * What the extract was pointed at, as that project calls itself.
+   *
+   * A path is relative to wherever the extract ran, so two services in
+   * one repository both say `src/handlers.ts` and merging their
+   * summaries puts them on top of each other. This is what tells them
+   * apart, and what a reader groups by.
+   */
+  workspace: z.string().optional()
 });
 var RestSemanticsSchema = z.object({
   name: z.literal("rest"),
@@ -129,6 +138,9 @@ var BoundaryBindingSchema = z.object({
   semantics: SemanticsSchema,
   recognition: z.string()
 });
+function typeDefinitionKey(ref) {
+  return ref.def ?? null;
+}
 var TypeShapeSchema = z.lazy(
   () => z.discriminatedUnion("type", [
     z.object({
@@ -156,11 +168,52 @@ var TypeShapeSchema = z.lazy(
     z.object({
       type: z.literal("ref"),
       name: z.string(),
-      from: z.string().optional()
+      from: z.string().optional(),
+      def: z.string().optional()
     }),
     z.object({ type: z.literal("unknown") })
   ])
 );
+var MAX_DEFINITION_DEPTH = 6;
+function withDefinitionsInlined(shape, definitions, depth = 0, inProgress = /* @__PURE__ */ new Set()) {
+  if (definitions === void 0 || depth >= MAX_DEFINITION_DEPTH) {
+    return shape;
+  }
+  const deeper = (inner) => withDefinitionsInlined(inner, definitions, depth + 1, inProgress);
+  if (shape.type === "ref") {
+    const key = typeDefinitionKey(shape);
+    if (key === null) {
+      return shape;
+    }
+    const defined = definitions[key];
+    if (defined === void 0 || inProgress.has(key)) {
+      return shape;
+    }
+    return withDefinitionsInlined(
+      defined,
+      definitions,
+      depth,
+      /* @__PURE__ */ new Set([...inProgress, key])
+    );
+  }
+  if (shape.type === "record") {
+    const properties = {};
+    for (const [name, value] of Object.entries(shape.properties)) {
+      properties[name] = deeper(value);
+    }
+    return { ...shape, properties };
+  }
+  if (shape.type === "array") {
+    return { ...shape, items: deeper(shape.items) };
+  }
+  if (shape.type === "dictionary") {
+    return { ...shape, values: deeper(shape.values) };
+  }
+  if (shape.type === "union") {
+    return { ...shape, variants: shape.variants.map(deeper) };
+  }
+  return shape;
+}
 
 export {
   ConfidenceSourceSchema,
@@ -178,5 +231,7 @@ export {
   MessageBusSemanticsSchema,
   SemanticsSchema,
   BoundaryBindingSchema,
-  TypeShapeSchema
+  typeDefinitionKey,
+  TypeShapeSchema,
+  withDefinitionsInlined
 };

package/dist/index.cjs

@@ -59,7 +59,9 @@ __export(index_exports, {
   ruleBoundaryMatchesKey: () => ruleBoundaryMatchesKey,
   runtimeConfigBinding: () => runtimeConfigBinding,
   storageRelationalBinding: () => storageRelationalBinding,
-  validateRule: () => validateRule
+  typeDefinitionKey: () => typeDefinitionKey,
+  validateRule: () => validateRule,
+  withDefinitionsInlined: () => withDefinitionsInlined
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -89,7 +91,16 @@ var ConfidenceInfoSchema = import_zod.z.object({
 var SourceLocationSchema = import_zod.z.object({
   file: import_zod.z.string(),
   range: import_zod.z.object({ start: import_zod.z.number(), end: import_zod.z.number() }),
-  exportName: import_zod.z.string().nullable()
+  exportName: import_zod.z.string().nullable(),
+  /**
+   * What the extract was pointed at, as that project calls itself.
+   *
+   * A path is relative to wherever the extract ran, so two services in
+   * one repository both say `src/handlers.ts` and merging their
+   * summaries puts them on top of each other. This is what tells them
+   * apart, and what a reader groups by.
+   */
+  workspace: import_zod.z.string().optional()
 });
 var RestSemanticsSchema = import_zod.z.object({
   name: import_zod.z.literal("rest"),
@@ -194,6 +205,9 @@ var BoundaryBindingSchema = import_zod.z.object({
   semantics: SemanticsSchema,
   recognition: import_zod.z.string()
 });
+function typeDefinitionKey(ref) {
+  return ref.def ?? null;
+}
 var TypeShapeSchema = import_zod.z.lazy(
   () => import_zod.z.discriminatedUnion("type", [
     import_zod.z.object({
@@ -221,11 +235,52 @@ var TypeShapeSchema = import_zod.z.lazy(
     import_zod.z.object({
       type: import_zod.z.literal("ref"),
       name: import_zod.z.string(),
-      from: import_zod.z.string().optional()
+      from: import_zod.z.string().optional(),
+      def: import_zod.z.string().optional()
     }),
     import_zod.z.object({ type: import_zod.z.literal("unknown") })
   ])
 );
+var MAX_DEFINITION_DEPTH = 6;
+function withDefinitionsInlined(shape, definitions, depth = 0, inProgress = /* @__PURE__ */ new Set()) {
+  if (definitions === void 0 || depth >= MAX_DEFINITION_DEPTH) {
+    return shape;
+  }
+  const deeper = (inner) => withDefinitionsInlined(inner, definitions, depth + 1, inProgress);
+  if (shape.type === "ref") {
+    const key = typeDefinitionKey(shape);
+    if (key === null) {
+      return shape;
+    }
+    const defined = definitions[key];
+    if (defined === void 0 || inProgress.has(key)) {
+      return shape;
+    }
+    return withDefinitionsInlined(
+      defined,
+      definitions,
+      depth,
+      /* @__PURE__ */ new Set([...inProgress, key])
+    );
+  }
+  if (shape.type === "record") {
+    const properties = {};
+    for (const [name, value] of Object.entries(shape.properties)) {
+      properties[name] = deeper(value);
+    }
+    return { ...shape, properties };
+  }
+  if (shape.type === "array") {
+    return { ...shape, items: deeper(shape.items) };
+  }
+  if (shape.type === "dictionary") {
+    return { ...shape, values: deeper(shape.values) };
+  }
+  if (shape.type === "union") {
+    return { ...shape, variants: shape.variants.map(deeper) };
+  }
+  return shape;
+}
 
 // src/channel.ts
 function parseChannel(channel) {
@@ -709,5 +764,7 @@ function messageBusBinding(opts) {
   ruleBoundaryMatchesKey,
   runtimeConfigBinding,
   storageRelationalBinding,
-  validateRule
+  typeDefinitionKey,
+  validateRule,
+  withDefinitionsInlined
 });

package/dist/index.d.cts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { TypeShape, BoundaryBindingSchema, ConfidenceInfoSchema, ConfidenceLevelSchema, ConfidenceSourceSchema, CorroborationSchema, DeployableUnitSchema, SemanticsSchema, SourceLocationSchema } from './schemas.cjs';
-export { FunctionCallSemanticsSchema, GraphqlOperationSemanticsSchema, GraphqlResolverSemanticsSchema, MessageBusSemanticsSchema, RestSemanticsSchema, RuntimeConfigSemanticsSchema, StorageRelationalSemanticsSchema, TypeShapeSchema } from './schemas.cjs';
+export { FunctionCallSemanticsSchema, GraphqlOperationSemanticsSchema, GraphqlResolverSemanticsSchema, MessageBusSemanticsSchema, RestSemanticsSchema, RuntimeConfigSemanticsSchema, StorageRelationalSemanticsSchema, TypeShapeSchema, typeDefinitionKey, withDefinitionsInlined } from './schemas.cjs';
 
 /**
  * Normalize a route path to a canonical form for matching.

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { TypeShape, BoundaryBindingSchema, ConfidenceInfoSchema, ConfidenceLevelSchema, ConfidenceSourceSchema, CorroborationSchema, DeployableUnitSchema, SemanticsSchema, SourceLocationSchema } from './schemas.js';
-export { FunctionCallSemanticsSchema, GraphqlOperationSemanticsSchema, GraphqlResolverSemanticsSchema, MessageBusSemanticsSchema, RestSemanticsSchema, RuntimeConfigSemanticsSchema, StorageRelationalSemanticsSchema, TypeShapeSchema } from './schemas.js';
+export { FunctionCallSemanticsSchema, GraphqlOperationSemanticsSchema, GraphqlResolverSemanticsSchema, MessageBusSemanticsSchema, RestSemanticsSchema, RuntimeConfigSemanticsSchema, StorageRelationalSemanticsSchema, TypeShapeSchema, typeDefinitionKey, withDefinitionsInlined } from './schemas.js';
 
 /**
  * Normalize a route path to a canonical form for matching.

package/dist/index.js

@@ -14,8 +14,10 @@ import {
   SemanticsSchema,
   SourceLocationSchema,
   StorageRelationalSemanticsSchema,
-  TypeShapeSchema
-} from "./chunk-QQLJDL3C.js";
+  TypeShapeSchema,
+  typeDefinitionKey,
+  withDefinitionsInlined
+} from "./chunk-L4XGOS3I.js";
 
 // src/channel.ts
 function parseChannel(channel) {
@@ -498,5 +500,7 @@ export {
   ruleBoundaryMatchesKey,
   runtimeConfigBinding,
   storageRelationalBinding,
-  validateRule
+  typeDefinitionKey,
+  validateRule,
+  withDefinitionsInlined
 };

package/dist/schemas.cjs

@@ -35,7 +35,9 @@ __export(schemas_exports, {
   SemanticsSchema: () => SemanticsSchema,
   SourceLocationSchema: () => SourceLocationSchema,
   StorageRelationalSemanticsSchema: () => StorageRelationalSemanticsSchema,
-  TypeShapeSchema: () => TypeShapeSchema
+  TypeShapeSchema: () => TypeShapeSchema,
+  typeDefinitionKey: () => typeDefinitionKey,
+  withDefinitionsInlined: () => withDefinitionsInlined
 });
 module.exports = __toCommonJS(schemas_exports);
 var import_zod = require("zod");
@@ -63,7 +65,16 @@ var ConfidenceInfoSchema = import_zod.z.object({
 var SourceLocationSchema = import_zod.z.object({
   file: import_zod.z.string(),
   range: import_zod.z.object({ start: import_zod.z.number(), end: import_zod.z.number() }),
-  exportName: import_zod.z.string().nullable()
+  exportName: import_zod.z.string().nullable(),
+  /**
+   * What the extract was pointed at, as that project calls itself.
+   *
+   * A path is relative to wherever the extract ran, so two services in
+   * one repository both say `src/handlers.ts` and merging their
+   * summaries puts them on top of each other. This is what tells them
+   * apart, and what a reader groups by.
+   */
+  workspace: import_zod.z.string().optional()
 });
 var RestSemanticsSchema = import_zod.z.object({
   name: import_zod.z.literal("rest"),
@@ -168,6 +179,9 @@ var BoundaryBindingSchema = import_zod.z.object({
   semantics: SemanticsSchema,
   recognition: import_zod.z.string()
 });
+function typeDefinitionKey(ref) {
+  return ref.def ?? null;
+}
 var TypeShapeSchema = import_zod.z.lazy(
   () => import_zod.z.discriminatedUnion("type", [
     import_zod.z.object({
@@ -195,11 +209,52 @@ var TypeShapeSchema = import_zod.z.lazy(
     import_zod.z.object({
       type: import_zod.z.literal("ref"),
       name: import_zod.z.string(),
-      from: import_zod.z.string().optional()
+      from: import_zod.z.string().optional(),
+      def: import_zod.z.string().optional()
     }),
     import_zod.z.object({ type: import_zod.z.literal("unknown") })
   ])
 );
+var MAX_DEFINITION_DEPTH = 6;
+function withDefinitionsInlined(shape, definitions, depth = 0, inProgress = /* @__PURE__ */ new Set()) {
+  if (definitions === void 0 || depth >= MAX_DEFINITION_DEPTH) {
+    return shape;
+  }
+  const deeper = (inner) => withDefinitionsInlined(inner, definitions, depth + 1, inProgress);
+  if (shape.type === "ref") {
+    const key = typeDefinitionKey(shape);
+    if (key === null) {
+      return shape;
+    }
+    const defined = definitions[key];
+    if (defined === void 0 || inProgress.has(key)) {
+      return shape;
+    }
+    return withDefinitionsInlined(
+      defined,
+      definitions,
+      depth,
+      /* @__PURE__ */ new Set([...inProgress, key])
+    );
+  }
+  if (shape.type === "record") {
+    const properties = {};
+    for (const [name, value] of Object.entries(shape.properties)) {
+      properties[name] = deeper(value);
+    }
+    return { ...shape, properties };
+  }
+  if (shape.type === "array") {
+    return { ...shape, items: deeper(shape.items) };
+  }
+  if (shape.type === "dictionary") {
+    return { ...shape, values: deeper(shape.values) };
+  }
+  if (shape.type === "union") {
+    return { ...shape, variants: shape.variants.map(deeper) };
+  }
+  return shape;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BoundaryBindingSchema,
@@ -217,5 +272,7 @@ var TypeShapeSchema = import_zod.z.lazy(
   SemanticsSchema,
   SourceLocationSchema,
   StorageRelationalSemanticsSchema,
-  TypeShapeSchema
+  TypeShapeSchema,
+  typeDefinitionKey,
+  withDefinitionsInlined
 });

package/dist/schemas.d.cts

@@ -64,6 +64,7 @@ declare const SourceLocationSchema: z.ZodObject<{
         end: z.ZodNumber;
     }, z.core.$strip>;
     exportName: z.ZodNullable<z.ZodString>;
+    workspace: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 declare const RestSemanticsSchema: z.ZodObject<{
     name: z.ZodLiteral<"rest">;
@@ -317,6 +318,17 @@ type TypeShape = {
 } | {
     type: "ref";
     name: string;
+    /**
+     * Where this type is written down, when 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 hands the second one the first one's
+     * fields. This 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
@@ -330,6 +342,33 @@ type TypeShape = {
 } | {
     type: "unknown";
 };
+/**
+ * How a table of definitions names the type a ref points at.
+ *
+ * A ref carries 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 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 names put 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
+ * table goes back into the shape once, and everything downstream reads
+ * what it always read.
+ *
+ * Putting a definition back is a substitution rather than a level of
+ * nesting, so it does not spend depth. Counting it did: a type six
+ * deep came back three deep, and a consumer reading a field past that
+ * point was told the provider did not have it. What stops a type that
+ * names itself is the set of names already being put back on this
+ * path, which is how the shape walk guards its own cycles.
+ */
+declare function withDefinitionsInlined(shape: TypeShape, definitions: Record<string, TypeShape> | undefined, depth?: number, inProgress?: ReadonlySet<string>): TypeShape;
 
-export { BoundaryBindingSchema, ConfidenceInfoSchema, ConfidenceLevelSchema, ConfidenceSourceSchema, CorroborationSchema, DeployableUnitSchema, FunctionCallSemanticsSchema, GraphqlOperationSemanticsSchema, GraphqlResolverSemanticsSchema, MessageBusSemanticsSchema, RestSemanticsSchema, RuntimeConfigSemanticsSchema, SemanticsSchema, SourceLocationSchema, StorageRelationalSemanticsSchema, type TypeShape, TypeShapeSchema };
+export { BoundaryBindingSchema, ConfidenceInfoSchema, ConfidenceLevelSchema, ConfidenceSourceSchema, CorroborationSchema, DeployableUnitSchema, FunctionCallSemanticsSchema, GraphqlOperationSemanticsSchema, GraphqlResolverSemanticsSchema, MessageBusSemanticsSchema, RestSemanticsSchema, RuntimeConfigSemanticsSchema, SemanticsSchema, SourceLocationSchema, StorageRelationalSemanticsSchema, type TypeShape, TypeShapeSchema, typeDefinitionKey, withDefinitionsInlined };

package/dist/schemas.d.ts

@@ -64,6 +64,7 @@ declare const SourceLocationSchema: z.ZodObject<{
         end: z.ZodNumber;
     }, z.core.$strip>;
     exportName: z.ZodNullable<z.ZodString>;
+    workspace: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 declare const RestSemanticsSchema: z.ZodObject<{
     name: z.ZodLiteral<"rest">;
@@ -317,6 +318,17 @@ type TypeShape = {
 } | {
     type: "ref";
     name: string;
+    /**
+     * Where this type is written down, when 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 hands the second one the first one's
+     * fields. This 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
@@ -330,6 +342,33 @@ type TypeShape = {
 } | {
     type: "unknown";
 };
+/**
+ * How a table of definitions names the type a ref points at.
+ *
+ * A ref carries 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 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 names put 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
+ * table goes back into the shape once, and everything downstream reads
+ * what it always read.
+ *
+ * Putting a definition back is a substitution rather than a level of
+ * nesting, so it does not spend depth. Counting it did: a type six
+ * deep came back three deep, and a consumer reading a field past that
+ * point was told the provider did not have it. What stops a type that
+ * names itself is the set of names already being put back on this
+ * path, which is how the shape walk guards its own cycles.
+ */
+declare function withDefinitionsInlined(shape: TypeShape, definitions: Record<string, TypeShape> | undefined, depth?: number, inProgress?: ReadonlySet<string>): TypeShape;
 
-export { BoundaryBindingSchema, ConfidenceInfoSchema, ConfidenceLevelSchema, ConfidenceSourceSchema, CorroborationSchema, DeployableUnitSchema, FunctionCallSemanticsSchema, GraphqlOperationSemanticsSchema, GraphqlResolverSemanticsSchema, MessageBusSemanticsSchema, RestSemanticsSchema, RuntimeConfigSemanticsSchema, SemanticsSchema, SourceLocationSchema, StorageRelationalSemanticsSchema, type TypeShape, TypeShapeSchema };
+export { BoundaryBindingSchema, ConfidenceInfoSchema, ConfidenceLevelSchema, ConfidenceSourceSchema, CorroborationSchema, DeployableUnitSchema, FunctionCallSemanticsSchema, GraphqlOperationSemanticsSchema, GraphqlResolverSemanticsSchema, MessageBusSemanticsSchema, RestSemanticsSchema, RuntimeConfigSemanticsSchema, SemanticsSchema, SourceLocationSchema, StorageRelationalSemanticsSchema, type TypeShape, TypeShapeSchema, typeDefinitionKey, withDefinitionsInlined };

package/dist/schemas.js

@@ -14,8 +14,10 @@ import {
   SemanticsSchema,
   SourceLocationSchema,
   StorageRelationalSemanticsSchema,
-  TypeShapeSchema
-} from "./chunk-QQLJDL3C.js";
+  TypeShapeSchema,
+  typeDefinitionKey,
+  withDefinitionsInlined
+} from "./chunk-L4XGOS3I.js";
 export {
   BoundaryBindingSchema,
   ConfidenceInfoSchema,
@@ -32,5 +34,7 @@ export {
   SemanticsSchema,
   SourceLocationSchema,
   StorageRelationalSemanticsSchema,
-  TypeShapeSchema
+  TypeShapeSchema,
+  typeDefinitionKey,
+  withDefinitionsInlined
 };

package/package.json

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