@anvia/graph 0.0.0-bootstrap.0 → 1.0.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Indra Zulfi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,79 @@
 # @anvia/graph
 
-Bootstrap placeholder. The production package is published from the Anvia release workflow.
+Provider-neutral schema, extraction, retrieval-context, and tool primitives for knowledge graphs.
+
+```ts
+import { defineGraphSchema, extractGraphFacts } from "@anvia/graph";
+import { z } from "zod";
+
+const schema = defineGraphSchema({
+  nodes: {
+    Product: {
+      description: "A product or service.",
+      identity: ["id"],
+      properties: z.strictObject({ id: z.string(), name: z.string() }),
+    },
+  },
+  relationships: {},
+});
+
+const facts = await extractGraphFacts({ model, schema, chunks });
+```
+
+Database provisioning, persistence, and query execution belong to graph adapter packages such as
+`@anvia/neo4j` and `@anvia/memgraph`.
+
+## Search tool
+
+Create the same Agent tool for any graph adapter implementing `GraphContextRetriever`:
+
+```ts
+import { createGraphSearchTool } from "@anvia/graph";
+
+const searchGraph = createGraphSearchTool({
+  name: "search_graph",
+  description: "Search connected entities and supporting evidence.",
+  graph,
+  model: embeddingModel,
+  search: {
+    type: "vector",
+    seeds: ["entities"],
+    topK: 8,
+  },
+  traversal: {
+    relationships: ["AFFECTS"],
+    direction: "both",
+    maxDepth: 2,
+    maxNodes: 40,
+    maxRelationships: 80,
+  },
+  evidence: { type: "chunks", maxChunks: 12 },
+});
+```
+
+The graph registration controls which evidence modes are valid. Managed graphs can hydrate stored
+chunks, while existing graph registrations use `{ type: "none" }`.
+
+## Exploration
+
+Adapters implementing `GraphExplorer` expose a portable, bounded view for visualization:
+
+```ts
+const overview = await graph.explore({
+  mode: "overview",
+  nodeTypes: ["Product"],
+  maxNodes: 100,
+  maxRelationships: 200,
+});
+
+const neighborhood = await graph.explore({
+  mode: "expand",
+  nodeIds: [overview.nodes[0]!.id],
+  direction: "both",
+  maxDepth: 1,
+});
+```
+
+Explorer IDs are opaque and provider-specific. They are intended for follow-up expansion within the
+same graph, not persistence or cross-provider migration. Adapters cap overview and expansion requests,
+return truncation metadata, and omit reserved Anvia properties such as stored embeddings.

package/dist/chunk-N3CKMOPE.js

@@ -0,0 +1,85 @@
+// src/explore.ts
+var defaultMaxNodes = 100;
+var maximumNodes = 500;
+var defaultMaxRelationships = 200;
+var maximumRelationships = 1e3;
+var defaultMaxDepth = 1;
+var maximumDepth = 4;
+var maximumRoots = 20;
+function resolveGraphExploreOptions(schema, options) {
+  const nodeTypes = resolveNames(options.nodeTypes, Object.keys(schema.nodes), "node type");
+  const relationships = resolveNames(
+    options.relationships,
+    Object.keys(schema.relationships),
+    "relationship type",
+    true
+  );
+  const base = {
+    nodeTypes,
+    relationships,
+    maxNodes: boundedInteger(options.maxNodes, defaultMaxNodes, maximumNodes, "maxNodes"),
+    maxRelationships: boundedInteger(
+      options.maxRelationships,
+      defaultMaxRelationships,
+      maximumRelationships,
+      "maxRelationships"
+    )
+  };
+  if (options.abortSignal !== void 0) base.abortSignal = options.abortSignal;
+  if (options.mode === "overview") {
+    return { ...base, mode: "overview" };
+  }
+  const nodeIds = uniqueNonEmptyStrings(options.nodeIds, "node id");
+  if (nodeIds.length === 0) {
+    throw new TypeError("Graph expansion requires at least one node id.");
+  }
+  if (nodeIds.length > maximumRoots) {
+    throw new RangeError(`Graph expansion accepts at most ${maximumRoots} root nodes.`);
+  }
+  const direction = options.direction ?? "both";
+  if (direction !== "outgoing" && direction !== "incoming" && direction !== "both") {
+    throw new TypeError("Graph expansion direction must be outgoing, incoming, or both.");
+  }
+  return {
+    ...base,
+    mode: "expand",
+    nodeIds,
+    direction,
+    maxDepth: boundedInteger(options.maxDepth, defaultMaxDepth, maximumDepth, "maxDepth")
+  };
+}
+function resolveNames(selected, available, label, allowEmpty = false) {
+  const values = selected === void 0 ? [...available] : uniqueNonEmptyStrings(selected, label);
+  if (!allowEmpty && values.length === 0) {
+    throw new TypeError(`Graph exploration requires at least one ${label}.`);
+  }
+  const known = new Set(available);
+  for (const value of values) {
+    if (!known.has(value))
+      throw new TypeError(`Graph exploration references unknown ${label} ${value}.`);
+  }
+  return values;
+}
+function uniqueNonEmptyStrings(values, label) {
+  const unique = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    if (typeof value !== "string" || value.length === 0) {
+      throw new TypeError(`Graph ${label} must be a non-empty string.`);
+    }
+    if (unique.has(value)) throw new TypeError(`Duplicate graph ${label}: ${value}.`);
+    unique.add(value);
+  }
+  return [...unique];
+}
+function boundedInteger(value, fallback, maximum, label) {
+  const resolved = value ?? fallback;
+  if (!Number.isSafeInteger(resolved) || resolved < 1 || resolved > maximum) {
+    throw new RangeError(`Graph exploration ${label} must be between 1 and ${maximum}.`);
+  }
+  return resolved;
+}
+
+export {
+  resolveGraphExploreOptions
+};
+//# sourceMappingURL=chunk-N3CKMOPE.js.map

package/dist/chunk-N3CKMOPE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/explore.ts"],"sourcesContent":["import type { GraphExploreDirection, GraphExploreOptions, GraphSchemaLike } from \"./types.js\";\n\nconst defaultMaxNodes = 100;\nconst maximumNodes = 500;\nconst defaultMaxRelationships = 200;\nconst maximumRelationships = 1_000;\nconst defaultMaxDepth = 1;\nconst maximumDepth = 4;\nconst maximumRoots = 20;\n\ntype ResolvedGraphExploreBase = Readonly<{\n  nodeTypes: readonly string[];\n  relationships: readonly string[];\n  maxNodes: number;\n  maxRelationships: number;\n  abortSignal?: AbortSignal | undefined;\n}>;\n\nexport type ResolvedGraphExploreOverviewOptions = ResolvedGraphExploreBase &\n  Readonly<{ mode: \"overview\" }>;\n\nexport type ResolvedGraphExploreExpandOptions = ResolvedGraphExploreBase &\n  Readonly<{\n    mode: \"expand\";\n    nodeIds: readonly string[];\n    direction: GraphExploreDirection;\n    maxDepth: number;\n  }>;\n\nexport type ResolvedGraphExploreOptions =\n  | ResolvedGraphExploreOverviewOptions\n  | ResolvedGraphExploreExpandOptions;\n\nexport function resolveGraphExploreOptions<Schema extends GraphSchemaLike>(\n  schema: Schema,\n  options: GraphExploreOptions<Schema>,\n): ResolvedGraphExploreOptions {\n  const nodeTypes = resolveNames(options.nodeTypes, Object.keys(schema.nodes), \"node type\");\n  const relationships = resolveNames(\n    options.relationships,\n    Object.keys(schema.relationships),\n    \"relationship type\",\n    true,\n  );\n  const base: {\n    nodeTypes: string[];\n    relationships: string[];\n    maxNodes: number;\n    maxRelationships: number;\n    abortSignal?: AbortSignal | undefined;\n  } = {\n    nodeTypes,\n    relationships,\n    maxNodes: boundedInteger(options.maxNodes, defaultMaxNodes, maximumNodes, \"maxNodes\"),\n    maxRelationships: boundedInteger(\n      options.maxRelationships,\n      defaultMaxRelationships,\n      maximumRelationships,\n      \"maxRelationships\",\n    ),\n  };\n  if (options.abortSignal !== undefined) base.abortSignal = options.abortSignal;\n  if (options.mode === \"overview\") {\n    return { ...base, mode: \"overview\" };\n  }\n  const nodeIds = uniqueNonEmptyStrings(options.nodeIds, \"node id\");\n  if (nodeIds.length === 0) {\n    throw new TypeError(\"Graph expansion requires at least one node id.\");\n  }\n  if (nodeIds.length > maximumRoots) {\n    throw new RangeError(`Graph expansion accepts at most ${maximumRoots} root nodes.`);\n  }\n  const direction = options.direction ?? \"both\";\n  if (direction !== \"outgoing\" && direction !== \"incoming\" && direction !== \"both\") {\n    throw new TypeError(\"Graph expansion direction must be outgoing, incoming, or both.\");\n  }\n  return {\n    ...base,\n    mode: \"expand\",\n    nodeIds,\n    direction,\n    maxDepth: boundedInteger(options.maxDepth, defaultMaxDepth, maximumDepth, \"maxDepth\"),\n  };\n}\n\nfunction resolveNames(\n  selected: readonly string[] | undefined,\n  available: readonly string[],\n  label: string,\n  allowEmpty = false,\n): string[] {\n  const values = selected === undefined ? [...available] : uniqueNonEmptyStrings(selected, label);\n  if (!allowEmpty && values.length === 0) {\n    throw new TypeError(`Graph exploration requires at least one ${label}.`);\n  }\n  const known = new Set(available);\n  for (const value of values) {\n    if (!known.has(value))\n      throw new TypeError(`Graph exploration references unknown ${label} ${value}.`);\n  }\n  return values;\n}\n\nfunction uniqueNonEmptyStrings(values: readonly string[], label: string): string[] {\n  const unique = new Set<string>();\n  for (const value of values) {\n    if (typeof value !== \"string\" || value.length === 0) {\n      throw new TypeError(`Graph ${label} must be a non-empty string.`);\n    }\n    if (unique.has(value)) throw new TypeError(`Duplicate graph ${label}: ${value}.`);\n    unique.add(value);\n  }\n  return [...unique];\n}\n\nfunction boundedInteger(\n  value: number | undefined,\n  fallback: number,\n  maximum: number,\n  label: string,\n): number {\n  const resolved = value ?? fallback;\n  if (!Number.isSafeInteger(resolved) || resolved < 1 || resolved > maximum) {\n    throw new RangeError(`Graph exploration ${label} must be between 1 and ${maximum}.`);\n  }\n  return resolved;\n}\n"],"mappings":";AAEA,IAAM,kBAAkB;AACxB,IAAM,eAAe;AACrB,IAAM,0BAA0B;AAChC,IAAM,uBAAuB;AAC7B,IAAM,kBAAkB;AACxB,IAAM,eAAe;AACrB,IAAM,eAAe;AAyBd,SAAS,2BACd,QACA,SAC6B;AAC7B,QAAM,YAAY,aAAa,QAAQ,WAAW,OAAO,KAAK,OAAO,KAAK,GAAG,WAAW;AACxF,QAAM,gBAAgB;AAAA,IACpB,QAAQ;AAAA,IACR,OAAO,KAAK,OAAO,aAAa;AAAA,IAChC;AAAA,IACA;AAAA,EACF;AACA,QAAM,OAMF;AAAA,IACF;AAAA,IACA;AAAA,IACA,UAAU,eAAe,QAAQ,UAAU,iBAAiB,cAAc,UAAU;AAAA,IACpF,kBAAkB;AAAA,MAChB,QAAQ;AAAA,MACR;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF;AACA,MAAI,QAAQ,gBAAgB,OAAW,MAAK,cAAc,QAAQ;AAClE,MAAI,QAAQ,SAAS,YAAY;AAC/B,WAAO,EAAE,GAAG,MAAM,MAAM,WAAW;AAAA,EACrC;AACA,QAAM,UAAU,sBAAsB,QAAQ,SAAS,SAAS;AAChE,MAAI,QAAQ,WAAW,GAAG;AACxB,UAAM,IAAI,UAAU,gDAAgD;AAAA,EACtE;AACA,MAAI,QAAQ,SAAS,cAAc;AACjC,UAAM,IAAI,WAAW,mCAAmC,YAAY,cAAc;AAAA,EACpF;AACA,QAAM,YAAY,QAAQ,aAAa;AACvC,MAAI,cAAc,cAAc,cAAc,cAAc,cAAc,QAAQ;AAChF,UAAM,IAAI,UAAU,gEAAgE;AAAA,EACtF;AACA,SAAO;AAAA,IACL,GAAG;AAAA,IACH,MAAM;AAAA,IACN;AAAA,IACA;AAAA,IACA,UAAU,eAAe,QAAQ,UAAU,iBAAiB,cAAc,UAAU;AAAA,EACtF;AACF;AAEA,SAAS,aACP,UACA,WACA,OACA,aAAa,OACH;AACV,QAAM,SAAS,aAAa,SAAY,CAAC,GAAG,SAAS,IAAI,sBAAsB,UAAU,KAAK;AAC9F,MAAI,CAAC,cAAc,OAAO,WAAW,GAAG;AACtC,UAAM,IAAI,UAAU,2CAA2C,KAAK,GAAG;AAAA,EACzE;AACA,QAAM,QAAQ,IAAI,IAAI,SAAS;AAC/B,aAAW,SAAS,QAAQ;AAC1B,QAAI,CAAC,MAAM,IAAI,KAAK;AAClB,YAAM,IAAI,UAAU,wCAAwC,KAAK,IAAI,KAAK,GAAG;AAAA,EACjF;AACA,SAAO;AACT;AAEA,SAAS,sBAAsB,QAA2B,OAAyB;AACjF,QAAM,SAAS,oBAAI,IAAY;AAC/B,aAAW,SAAS,QAAQ;AAC1B,QAAI,OAAO,UAAU,YAAY,MAAM,WAAW,GAAG;AACnD,YAAM,IAAI,UAAU,SAAS,KAAK,8BAA8B;AAAA,IAClE;AACA,QAAI,OAAO,IAAI,KAAK,EAAG,OAAM,IAAI,UAAU,mBAAmB,KAAK,KAAK,KAAK,GAAG;AAChF,WAAO,IAAI,KAAK;AAAA,EAClB;AACA,SAAO,CAAC,GAAG,MAAM;AACnB;AAEA,SAAS,eACP,OACA,UACA,SACA,OACQ;AACR,QAAM,WAAW,SAAS;AAC1B,MAAI,CAAC,OAAO,cAAc,QAAQ,KAAK,WAAW,KAAK,WAAW,SAAS;AACzE,UAAM,IAAI,WAAW,qBAAqB,KAAK,0BAA0B,OAAO,GAAG;AAAA,EACrF;AACA,SAAO;AACT;","names":[]}

package/dist/explore-B2BuWiSK.d.ts

@@ -0,0 +1,261 @@
+import { RetrySetting, CompletionModel, Usage } from '@anvia/core';
+import { EmbeddingModel } from '@anvia/core/embeddings';
+import { Tool } from '@anvia/core/tool';
+import { z } from 'zod';
+
+type GraphPropertyPrimitive = string | number | boolean;
+type GraphPropertyValue = GraphPropertyPrimitive | readonly string[] | readonly number[] | readonly boolean[];
+type GraphProperties = Readonly<Record<string, GraphPropertyValue>>;
+type GraphNodeIdentity = Readonly<Record<string, GraphPropertyPrimitive>>;
+type GraphNodeDefinition = Readonly<{
+    description: string;
+    identity: readonly string[];
+    properties: z.ZodObject<z.ZodRawShape>;
+}>;
+type GraphRelationshipDefinition = Readonly<{
+    description: string;
+    from: string;
+    to: string;
+    identity?: readonly string[] | undefined;
+    properties: z.ZodObject<z.ZodRawShape>;
+}>;
+type GraphSchemaOptions = Readonly<{
+    nodes: Readonly<Record<string, GraphNodeDefinition>>;
+    relationships: Readonly<Record<string, GraphRelationshipDefinition>>;
+}>;
+type GraphSchema<Options extends GraphSchemaOptions = GraphSchemaOptions> = Readonly<Options & {
+    kind: "graph-schema";
+}>;
+type GraphSchemaLike<Options extends GraphSchemaOptions = GraphSchemaOptions> = Readonly<Options & {
+    kind: string;
+}>;
+type NodeDefinitions<Schema extends GraphSchemaLike> = Schema["nodes"];
+type RelationshipDefinitions<Schema extends GraphSchemaLike> = Schema["relationships"];
+type GraphEntity<Schema extends GraphSchemaLike = GraphSchemaLike> = {
+    [Type in keyof NodeDefinitions<Schema> & string]: Readonly<{
+        key: string;
+        type: Type;
+        identity: GraphNodeIdentity;
+        properties: z.output<NodeDefinitions<Schema>[Type]["properties"]> & GraphProperties;
+        sourceChunkIds: readonly string[];
+    }>;
+}[keyof NodeDefinitions<Schema> & string];
+type GraphRelationship<Schema extends GraphSchemaLike = GraphSchemaLike> = {
+    [Type in keyof RelationshipDefinitions<Schema> & string]: Readonly<{
+        key: string;
+        type: Type;
+        from: string;
+        to: string;
+        properties: z.output<RelationshipDefinitions<Schema>[Type]["properties"]> & GraphProperties;
+        sourceChunkIds: readonly string[];
+    }>;
+}[keyof RelationshipDefinitions<Schema> & string];
+type GraphMention = Readonly<{
+    chunkId: string;
+    entityKey: string;
+}>;
+type GraphFacts<Schema extends GraphSchemaLike = GraphSchemaLike> = Readonly<{
+    entities: readonly GraphEntity<Schema>[];
+    relationships: readonly GraphRelationship<Schema>[];
+    mentions: readonly GraphMention[];
+}>;
+type GraphChunk<Metadata extends GraphProperties = GraphProperties> = Readonly<{
+    id: string;
+    documentId: string;
+    index: number;
+    text: string;
+    metadata?: Metadata | undefined;
+}>;
+type GraphDocument<Properties extends GraphProperties = GraphProperties> = Readonly<{
+    id: string;
+    properties?: Properties | undefined;
+}>;
+type ExtractGraphFactsOptions<Schema extends GraphSchemaLike, Model extends CompletionModel> = Readonly<{
+    model: Model;
+    schema: Schema;
+    chunks: readonly GraphChunk[];
+    instructions?: string | undefined;
+    retries?: RetrySetting | undefined;
+    concurrency?: number | undefined;
+    abortSignal?: AbortSignal | undefined;
+}>;
+type ExtractGraphFactsResult<Schema extends GraphSchemaLike> = Readonly<{
+    output: GraphFacts<Schema>;
+    usage: Usage;
+}>;
+type GraphVectorSearchOptions = Readonly<{
+    type: "vector";
+    seeds: readonly string[];
+    topK: number;
+    minScore?: number | undefined;
+}>;
+type GraphHybridSearchOptions = Readonly<{
+    type: "hybrid";
+    seeds: readonly string[];
+    topK: number;
+    candidatesPerSeed: number;
+    rrfK: number;
+}>;
+type GraphSearchOptions = GraphVectorSearchOptions | GraphHybridSearchOptions;
+type GraphEvidenceOptions = Readonly<{
+    type: "none";
+}> | Readonly<{
+    type: "chunks";
+    maxChunks: number;
+}>;
+type GraphTraversalOptions<Schema extends GraphSchemaLike = GraphSchemaLike> = Readonly<{
+    relationships: readonly (keyof Schema["relationships"] & string)[];
+    direction: "outgoing" | "incoming" | "both";
+    maxDepth: number;
+    maxNodes: number;
+    maxRelationships: number;
+}>;
+type GraphContextSeed = Readonly<{
+    key: string;
+    type: string;
+    score: number;
+    properties: GraphProperties;
+    sourceChunkIds: readonly string[];
+}>;
+type GraphContextNode = Readonly<{
+    key: string;
+    type: string;
+    identity: GraphNodeIdentity;
+    properties: GraphProperties;
+    sourceChunkIds: readonly string[];
+}>;
+type GraphContextRelationship = Readonly<{
+    key: string;
+    type: string;
+    from: string;
+    to: string;
+    properties: GraphProperties;
+    sourceChunkIds: readonly string[];
+}>;
+type GraphEvidence = Readonly<{
+    chunkId: string;
+    documentId: string;
+    index: number;
+    text: string;
+    metadata: GraphProperties;
+}>;
+type GraphContext = Readonly<{
+    seeds: readonly GraphContextSeed[];
+    nodes: readonly GraphContextNode[];
+    relationships: readonly GraphContextRelationship[];
+    evidence: readonly GraphEvidence[];
+}>;
+type GraphEvidenceCapability = "none" | "chunks";
+type GraphEvidenceFor<Capability extends GraphEvidenceCapability> = Extract<GraphEvidenceOptions, {
+    type: "none";
+}> | (Capability extends "chunks" ? Extract<GraphEvidenceOptions, {
+    type: "chunks";
+}> : never);
+type GraphRetrieveOptions<Schema extends GraphSchemaLike, Evidence extends GraphEvidenceCapability = GraphEvidenceCapability> = Readonly<{
+    model: EmbeddingModel;
+    query: string;
+    search: GraphSearchOptions;
+    traversal: GraphTraversalOptions<Schema>;
+    evidence: GraphEvidenceFor<Evidence>;
+    retries?: RetrySetting | undefined;
+    abortSignal?: AbortSignal | undefined;
+}>;
+interface GraphContextRetriever<Schema extends GraphSchemaLike = GraphSchemaLike, Evidence extends GraphEvidenceCapability = GraphEvidenceCapability> {
+    readonly evidenceCapability: Evidence;
+    retrieve(options: GraphRetrieveOptions<Schema, Evidence>): Promise<GraphContext>;
+}
+type GraphExploreDirection = "outgoing" | "incoming" | "both";
+type GraphExploreOverviewOptions<Schema extends GraphSchemaLike> = Readonly<{
+    mode: "overview";
+    nodeTypes?: readonly (keyof Schema["nodes"] & string)[] | undefined;
+    relationships?: readonly (keyof Schema["relationships"] & string)[] | undefined;
+    maxNodes?: number | undefined;
+    maxRelationships?: number | undefined;
+    abortSignal?: AbortSignal | undefined;
+}>;
+type GraphExploreExpandOptions<Schema extends GraphSchemaLike> = Readonly<{
+    mode: "expand";
+    nodeIds: readonly string[];
+    nodeTypes?: readonly (keyof Schema["nodes"] & string)[] | undefined;
+    relationships?: readonly (keyof Schema["relationships"] & string)[] | undefined;
+    direction?: GraphExploreDirection | undefined;
+    maxDepth?: number | undefined;
+    maxNodes?: number | undefined;
+    maxRelationships?: number | undefined;
+    abortSignal?: AbortSignal | undefined;
+}>;
+type GraphExploreOptions<Schema extends GraphSchemaLike> = GraphExploreOverviewOptions<Schema> | GraphExploreExpandOptions<Schema>;
+type GraphExploreNode = Readonly<{
+    id: string;
+    key?: string | undefined;
+    type: string;
+    identity: GraphNodeIdentity;
+    properties: GraphProperties;
+}>;
+type GraphExploreRelationship = Readonly<{
+    id: string;
+    key?: string | undefined;
+    type: string;
+    from: string;
+    to: string;
+    properties: GraphProperties;
+}>;
+type GraphExploreResult = Readonly<{
+    nodes: readonly GraphExploreNode[];
+    relationships: readonly GraphExploreRelationship[];
+    truncated: Readonly<{
+        nodes: boolean;
+        relationships: boolean;
+    }>;
+}>;
+interface GraphExplorer<Schema extends GraphSchemaLike = GraphSchemaLike> {
+    readonly schema: Schema;
+    explore(options: GraphExploreOptions<Schema>): Promise<GraphExploreResult>;
+}
+type CreateGraphSearchToolOptions<Schema extends GraphSchemaLike, Retriever extends GraphContextRetriever<Schema> = GraphContextRetriever<Schema>> = Readonly<{
+    name: string;
+    description: string;
+    graph: Retriever;
+    model: EmbeddingModel;
+    search: GraphSearchOptions;
+    traversal: GraphTraversalOptions<Schema>;
+    evidence: GraphEvidenceFor<Retriever["evidenceCapability"]>;
+    retries?: RetrySetting | undefined;
+}>;
+type GraphSearchTool = Tool<{
+    query: string;
+}, GraphContext>;
+type GraphChangeCounts = Readonly<{
+    created: number;
+    updated: number;
+    deleted: number;
+    unchanged: number;
+}>;
+type GraphWriteResult = Readonly<{
+    documents: GraphChangeCounts;
+    chunks: GraphChangeCounts;
+    entities: GraphChangeCounts;
+    relationships: GraphChangeCounts;
+    mentions: GraphChangeCounts;
+}>;
+
+type ResolvedGraphExploreBase = Readonly<{
+    nodeTypes: readonly string[];
+    relationships: readonly string[];
+    maxNodes: number;
+    maxRelationships: number;
+    abortSignal?: AbortSignal | undefined;
+}>;
+type ResolvedGraphExploreOverviewOptions = ResolvedGraphExploreBase & Readonly<{
+    mode: "overview";
+}>;
+type ResolvedGraphExploreExpandOptions = ResolvedGraphExploreBase & Readonly<{
+    mode: "expand";
+    nodeIds: readonly string[];
+    direction: GraphExploreDirection;
+    maxDepth: number;
+}>;
+type ResolvedGraphExploreOptions = ResolvedGraphExploreOverviewOptions | ResolvedGraphExploreExpandOptions;
+declare function resolveGraphExploreOptions<Schema extends GraphSchemaLike>(schema: Schema, options: GraphExploreOptions<Schema>): ResolvedGraphExploreOptions;
+
+export { type GraphExplorer as A, type GraphFacts as B, type CreateGraphSearchToolOptions as C, type GraphHybridSearchOptions as D, type ExtractGraphFactsOptions as E, type GraphMention as F, type GraphSchemaLike as G, type GraphNodeDefinition as H, type GraphNodeIdentity as I, type GraphPropertyPrimitive as J, type GraphRelationship as K, type GraphRelationshipDefinition as L, type GraphRetrieveOptions as M, type GraphSearchOptions as N, type GraphTraversalOptions as O, type GraphVectorSearchOptions as P, type GraphWriteResult as Q, type ResolvedGraphExploreExpandOptions as R, type ResolvedGraphExploreOptions as S, type ResolvedGraphExploreOverviewOptions as T, resolveGraphExploreOptions as U, type ExtractGraphFactsResult as a, type GraphSchemaOptions as b, type GraphSchema as c, type GraphProperties as d, type GraphPropertyValue as e, type GraphContextRetriever as f, type GraphSearchTool as g, type GraphChangeCounts as h, type GraphChunk as i, type GraphContext as j, type GraphContextNode as k, type GraphContextRelationship as l, type GraphContextSeed as m, type GraphDocument as n, type GraphEntity as o, type GraphEvidence as p, type GraphEvidenceCapability as q, type GraphEvidenceFor as r, type GraphEvidenceOptions as s, type GraphExploreDirection as t, type GraphExploreExpandOptions as u, type GraphExploreNode as v, type GraphExploreOptions as w, type GraphExploreOverviewOptions as x, type GraphExploreRelationship as y, type GraphExploreResult as z };

package/dist/explore.d.ts

@@ -0,0 +1,5 @@
+export { R as ResolvedGraphExploreExpandOptions, S as ResolvedGraphExploreOptions, T as ResolvedGraphExploreOverviewOptions, U as resolveGraphExploreOptions } from './explore-B2BuWiSK.js';
+import '@anvia/core';
+import '@anvia/core/embeddings';
+import '@anvia/core/tool';
+import 'zod';

package/dist/explore.js

@@ -0,0 +1,7 @@
+import {
+  resolveGraphExploreOptions
+} from "./chunk-N3CKMOPE.js";
+export {
+  resolveGraphExploreOptions
+};
+//# sourceMappingURL=explore.js.map

package/dist/explore.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+import * as _anvia_core from '@anvia/core';
+import { G as GraphSchemaLike, E as ExtractGraphFactsOptions, a as ExtractGraphFactsResult, b as GraphSchemaOptions, c as GraphSchema, d as GraphProperties, e as GraphPropertyValue, f as GraphContextRetriever, C as CreateGraphSearchToolOptions, g as GraphSearchTool } from './explore-B2BuWiSK.js';
+export { h as GraphChangeCounts, i as GraphChunk, j as GraphContext, k as GraphContextNode, l as GraphContextRelationship, m as GraphContextSeed, n as GraphDocument, o as GraphEntity, p as GraphEvidence, q as GraphEvidenceCapability, r as GraphEvidenceFor, s as GraphEvidenceOptions, t as GraphExploreDirection, u as GraphExploreExpandOptions, v as GraphExploreNode, w as GraphExploreOptions, x as GraphExploreOverviewOptions, y as GraphExploreRelationship, z as GraphExploreResult, A as GraphExplorer, B as GraphFacts, D as GraphHybridSearchOptions, F as GraphMention, H as GraphNodeDefinition, I as GraphNodeIdentity, J as GraphPropertyPrimitive, K as GraphRelationship, L as GraphRelationshipDefinition, M as GraphRetrieveOptions, N as GraphSearchOptions, O as GraphTraversalOptions, P as GraphVectorSearchOptions, Q as GraphWriteResult, R as ResolvedGraphExploreExpandOptions, S as ResolvedGraphExploreOptions, T as ResolvedGraphExploreOverviewOptions, U as resolveGraphExploreOptions } from './explore-B2BuWiSK.js';
+import '@anvia/core/embeddings';
+import '@anvia/core/tool';
+import 'zod';
+
+declare function extractGraphFacts<Schema extends GraphSchemaLike, Model extends _anvia_core.CompletionModel>(options: ExtractGraphFactsOptions<Schema, Model>): Promise<ExtractGraphFactsResult<Schema>>;
+declare class GraphFactConflictError extends Error {
+    readonly factKey: string;
+    readonly sourceChunkIds: readonly string[];
+    constructor(factKey: string, sourceChunkIds: readonly string[]);
+}
+
+declare const graphReservedPropertyPrefix = "__anvia_";
+declare function defineGraphSchema<const Options extends GraphSchemaOptions>(options: Options): GraphSchema<Options>;
+declare function validateGraphSchemaOptions(options: GraphSchemaOptions): void;
+declare function freezeGraphSchema<const Options extends GraphSchemaOptions, const Kind extends string>(options: Options, kind: Kind): Readonly<Options & {
+    kind: Kind;
+}>;
+declare function parseGraphProperties(value: unknown, label: string): GraphProperties;
+declare function parseGraphPropertyValue(value: unknown, label: string): GraphPropertyValue;
+declare function assertGraphName(value: string, label: string): void;
+declare function assertGraphPropertyName(value: string): void;
+
+declare function createGraphSearchTool<Schema extends GraphSchemaLike, Retriever extends GraphContextRetriever<Schema>>(options: CreateGraphSearchToolOptions<Schema, Retriever>): GraphSearchTool;
+
+export { CreateGraphSearchToolOptions, ExtractGraphFactsOptions, ExtractGraphFactsResult, GraphContextRetriever, GraphFactConflictError, GraphProperties, GraphPropertyValue, GraphSchema, GraphSchemaLike, GraphSchemaOptions, GraphSearchTool, assertGraphName, assertGraphPropertyName, createGraphSearchTool, defineGraphSchema, extractGraphFacts, freezeGraphSchema, graphReservedPropertyPrefix, parseGraphProperties, parseGraphPropertyValue, validateGraphSchemaOptions };

package/dist/index.js

@@ -0,0 +1,507 @@
+import {
+  resolveGraphExploreOptions
+} from "./chunk-N3CKMOPE.js";
+
+// src/extract.ts
+import { Usage } from "@anvia/core";
+import { extract } from "@anvia/core/extractor";
+import { z as z2 } from "zod";
+
+// src/schema.ts
+import { z } from "zod";
+var graphReservedPropertyPrefix = "__anvia_";
+function defineGraphSchema(options) {
+  validateGraphSchemaOptions(options);
+  return freezeGraphSchema(options, "graph-schema");
+}
+function validateGraphSchemaOptions(options) {
+  if (Object.keys(options.nodes).length === 0) {
+    throw new TypeError("A graph schema requires at least one node type.");
+  }
+  for (const [type, definition] of Object.entries(options.nodes)) {
+    assertGraphName(type, "node type");
+    assertDescription(definition.description, `node ${type}`);
+    if (!(definition.properties instanceof z.ZodObject)) {
+      throw new TypeError(`Properties for node ${type} must be a Zod object schema.`);
+    }
+    assertExactPropertySchema(definition.properties, `node ${type}`);
+    if (definition.identity.length === 0 || new Set(definition.identity).size !== definition.identity.length) {
+      throw new TypeError(`Node ${type} must declare unique identity properties.`);
+    }
+    for (const property of definition.identity) {
+      assertGraphPropertyName(property);
+      if (!(property in definition.properties.shape)) {
+        throw new TypeError(`Identity property ${property} is not declared by node ${type}.`);
+      }
+    }
+    for (const property of Object.keys(definition.properties.shape)) {
+      assertGraphPropertyName(property);
+    }
+  }
+  for (const [type, definition] of Object.entries(options.relationships)) {
+    assertGraphName(type, "relationship type");
+    assertDescription(definition.description, `relationship ${type}`);
+    if (!(definition.from in options.nodes) || !(definition.to in options.nodes)) {
+      throw new TypeError(`Relationship ${type} references an unknown endpoint type.`);
+    }
+    if (!(definition.properties instanceof z.ZodObject)) {
+      throw new TypeError(`Properties for relationship ${type} must be a Zod object schema.`);
+    }
+    assertExactPropertySchema(definition.properties, `relationship ${type}`);
+    const identity = definition.identity ?? [];
+    if (new Set(identity).size !== identity.length) {
+      throw new TypeError(`Relationship ${type} contains duplicate identity properties.`);
+    }
+    for (const property of Object.keys(definition.properties.shape)) {
+      assertGraphPropertyName(property);
+    }
+    for (const property of identity) {
+      if (!(property in definition.properties.shape)) {
+        throw new TypeError(
+          `Identity property ${property} is not declared by relationship ${type}.`
+        );
+      }
+    }
+  }
+}
+function freezeGraphSchema(options, kind) {
+  const nodes = Object.fromEntries(
+    Object.entries(options.nodes).map(([type, definition]) => [
+      type,
+      Object.freeze({ ...definition, identity: Object.freeze([...definition.identity]) })
+    ])
+  );
+  const relationships = Object.fromEntries(
+    Object.entries(options.relationships).map(([type, definition]) => {
+      const copy = { ...definition };
+      if (definition.identity !== void 0) {
+        Object.assign(copy, { identity: Object.freeze([...definition.identity]) });
+      }
+      return [type, Object.freeze(copy)];
+    })
+  );
+  return Object.freeze({
+    nodes: Object.freeze(nodes),
+    relationships: Object.freeze(relationships),
+    kind
+  });
+}
+function parseGraphProperties(value, label) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new TypeError(`${label} must be an object of graph property values.`);
+  }
+  const output = {};
+  for (const [key, item] of Object.entries(value)) {
+    assertGraphPropertyName(key);
+    output[key] = parseGraphPropertyValue(item, `${label}.${key}`);
+  }
+  return output;
+}
+function parseGraphPropertyValue(value, label) {
+  if (typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new TypeError(`${label} must be finite.`);
+    if (Number.isInteger(value) && !Number.isSafeInteger(value)) {
+      throw new TypeError(`${label} must be a safe integer.`);
+    }
+    return value;
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) return [];
+    const parsed = value.map((item, index) => parsePrimitive(item, `${label}[${index}]`));
+    const type = typeof parsed[0];
+    if (!parsed.every((item) => typeof item === type)) {
+      throw new TypeError(`${label} must be a homogeneous array.`);
+    }
+    return parsed;
+  }
+  throw new TypeError(`${label} is not a supported graph property value.`);
+}
+function assertGraphName(value, label) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new TypeError(`${label} must be a non-empty string.`);
+  }
+}
+function assertGraphPropertyName(value) {
+  assertGraphName(value, "graph property name");
+  if (value.startsWith(graphReservedPropertyPrefix)) {
+    throw new TypeError(
+      `Graph property names beginning with ${graphReservedPropertyPrefix} are reserved.`
+    );
+  }
+}
+function parsePrimitive(value, label) {
+  const parsed = parseGraphPropertyValue(value, label);
+  if (typeof parsed === "string" || typeof parsed === "number" || typeof parsed === "boolean") {
+    return parsed;
+  }
+  throw new TypeError(`${label} must be a primitive property value.`);
+}
+function assertDescription(value, label) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new TypeError(`${label} requires a non-empty description.`);
+  }
+}
+function assertExactPropertySchema(schema, label) {
+  const definition = schema._zod.def;
+  if (!(definition.catchall instanceof z.ZodNever)) {
+    throw new TypeError(`${label} properties must use a strict Zod object schema.`);
+  }
+  for (const [property, propertySchema] of Object.entries(schema.shape)) {
+    assertNonEffectfulSchema(propertySchema, `${label} property ${property}`, /* @__PURE__ */ new Set());
+  }
+}
+function assertNonEffectfulSchema(value, label, visited) {
+  if (!(value instanceof z.ZodType)) throw new TypeError(`${label} must be a Zod schema.`);
+  if (visited.has(value)) return;
+  visited.add(value);
+  const definition = value._zod.def;
+  const type = definition.type;
+  if (definition.coerce === true || type === "default" || type === "prefault" || type === "catch" || type === "transform" || type === "pipe") {
+    throw new TypeError(
+      `${label} must not coerce, default, transform, preprocess, or catch values.`
+    );
+  }
+  const checks = definition.checks;
+  if (Array.isArray(checks) && checks.some((check) => {
+    if (typeof check !== "object" || check === null) return false;
+    return check._zod?.def?.check === "overwrite";
+  })) {
+    throw new TypeError(`${label} must not normalize or overwrite values.`);
+  }
+  for (const child of schemaChildren(definition)) assertNonEffectfulSchema(child, label, visited);
+}
+function schemaChildren(definition) {
+  const children = [];
+  for (const key of ["innerType", "element", "left", "right", "rest", "keyType", "valueType"]) {
+    const value = definition[key];
+    if (value instanceof z.ZodType) children.push(value);
+  }
+  for (const key of ["options", "items"]) {
+    const value = definition[key];
+    if (Array.isArray(value)) {
+      for (const item of value) if (item instanceof z.ZodType) children.push(item);
+    }
+  }
+  return children;
+}
+
+// src/extract.ts
+async function extractGraphFacts(options) {
+  assertConcurrency(options.concurrency);
+  throwIfAborted(options.abortSignal);
+  const ids = /* @__PURE__ */ new Set();
+  for (const chunk of options.chunks) {
+    if (ids.has(chunk.id)) throw new TypeError(`Duplicate graph chunk id: ${chunk.id}`);
+    ids.add(chunk.id);
+    if (typeof chunk.text !== "string") {
+      throw new TypeError(`Graph chunk ${chunk.id} text must be a string.`);
+    }
+  }
+  const outputSchema = extractionSchema(options.schema);
+  const instructions = graphInstructions(options.schema, options.instructions);
+  const extractions = await mapConcurrent(
+    options.chunks,
+    options.concurrency ?? 1,
+    async (chunk) => {
+      throwIfAborted(options.abortSignal);
+      const result = await extract({
+        model: options.model,
+        text: chunk.text,
+        outputSchema,
+        instructions,
+        retries: options.retries,
+        abortSignal: options.abortSignal
+      });
+      return { chunkId: chunk.id, output: result.output, usage: result.usage };
+    }
+  );
+  return {
+    output: normalizeFacts(options.schema, extractions),
+    usage: extractions.reduce((usage, item) => Usage.add(usage, item.usage), Usage.empty())
+  };
+}
+function extractionSchema(schema) {
+  const entities = Object.entries(schema.nodes).map(
+    ([type, definition]) => z2.object({ ref: z2.string().min(1), type: z2.literal(type), properties: definition.properties })
+  );
+  const relationships = Object.entries(schema.relationships).map(
+    ([type, definition]) => z2.object({
+      type: z2.literal(type),
+      from: z2.string().min(1),
+      to: z2.string().min(1),
+      properties: definition.properties
+    })
+  );
+  return z2.object({
+    entities: z2.array(union(entities, z2.never())),
+    relationships: z2.array(union(relationships, z2.never()))
+  });
+}
+function union(items, empty) {
+  if (items.length === 0) return empty;
+  if (items.length === 1) return items[0];
+  return z2.union(items);
+}
+function graphInstructions(schema, extra) {
+  const nodes = Object.entries(schema.nodes).map(([type, definition]) => `- ${type}: ${definition.description}`).join("\n");
+  const relationships = Object.entries(schema.relationships).map(
+    ([type, definition]) => `- ${type}: ${definition.from} -> ${definition.to}. ${definition.description}`
+  ).join("\n");
+  return [
+    "Extract only facts directly supported by the source text.",
+    "Give every extracted entity a unique local ref and use those refs as relationship endpoints.",
+    "Do not invent entity or relationship types outside the declared schema.",
+    `Node types:
+${nodes}`,
+    relationships.length === 0 ? "No relationship types are allowed." : `Relationship types:
+${relationships}`,
+    extra
+  ].filter((part) => part !== void 0 && part.length > 0).join("\n\n");
+}
+function normalizeFacts(schema, extractions) {
+  const entities = /* @__PURE__ */ new Map();
+  const relationships = /* @__PURE__ */ new Map();
+  const mentions = /* @__PURE__ */ new Map();
+  for (const extraction of extractions) {
+    const refs = /* @__PURE__ */ new Map();
+    for (const raw of extraction.output.entities) {
+      if (refs.has(raw.ref)) {
+        throw new TypeError(`Duplicate entity ref ${raw.ref} in chunk ${extraction.chunkId}.`);
+      }
+      const definition = schema.nodes[raw.type];
+      if (definition === void 0) throw new TypeError(`Unknown graph entity type: ${raw.type}`);
+      const properties2 = parseGraphProperties(
+        definition.properties.parse(raw.properties),
+        `entity ${raw.type}`
+      );
+      const identity = identityFromProperties(definition.identity, properties2, raw.type);
+      const key = `${raw.type}:${stableObject(identity)}`;
+      const current = entities.get(key);
+      const next = {
+        key,
+        type: raw.type,
+        identity,
+        properties: properties2,
+        sourceChunkIds: [extraction.chunkId]
+      };
+      if (current === void 0) {
+        entities.set(key, next);
+        refs.set(raw.ref, next);
+      } else {
+        assertSameProperties(
+          current.properties,
+          properties2,
+          key,
+          current.sourceChunkIds,
+          extraction.chunkId
+        );
+        const merged = {
+          ...current,
+          sourceChunkIds: [...current.sourceChunkIds, extraction.chunkId]
+        };
+        entities.set(key, merged);
+        refs.set(raw.ref, merged);
+      }
+      mentions.set(`${extraction.chunkId}\0${key}`, {
+        chunkId: extraction.chunkId,
+        entityKey: key
+      });
+    }
+    for (const raw of extraction.output.relationships) {
+      const definition = schema.relationships[raw.type];
+      if (definition === void 0) {
+        throw new TypeError(`Unknown graph relationship type: ${raw.type}`);
+      }
+      const from = refs.get(raw.from);
+      const to = refs.get(raw.to);
+      if (from === void 0 || to === void 0) {
+        throw new TypeError(
+          `Relationship ${raw.type} in chunk ${extraction.chunkId} references an unknown entity ref.`
+        );
+      }
+      if (from.type !== definition.from || to.type !== definition.to) {
+        throw new TypeError(
+          `Relationship ${raw.type} has invalid endpoint types ${from.type} -> ${to.type}.`
+        );
+      }
+      const properties2 = parseGraphProperties(
+        definition.properties.parse(raw.properties),
+        `relationship ${raw.type}`
+      );
+      const identity = identityFromProperties(definition.identity ?? [], properties2, raw.type);
+      const key = `${raw.type}:${from.key}->${to.key}:${stableObject(identity)}`;
+      const current = relationships.get(key);
+      const next = {
+        key,
+        type: raw.type,
+        from: from.key,
+        to: to.key,
+        properties: properties2,
+        sourceChunkIds: [extraction.chunkId]
+      };
+      if (current === void 0) relationships.set(key, next);
+      else {
+        assertSameProperties(
+          current.properties,
+          properties2,
+          key,
+          current.sourceChunkIds,
+          extraction.chunkId
+        );
+        relationships.set(key, {
+          ...current,
+          sourceChunkIds: [...current.sourceChunkIds, extraction.chunkId]
+        });
+      }
+    }
+  }
+  return {
+    entities: [...entities.values()],
+    relationships: [...relationships.values()],
+    mentions: [...mentions.values()]
+  };
+}
+function identityFromProperties(keys, properties2, type) {
+  const identity = {};
+  for (const key of keys) {
+    const value = properties2[key];
+    if (value === void 0 || !(typeof value === "string" || typeof value === "number" || typeof value === "boolean")) {
+      throw new TypeError(`Identity property ${key} for ${type} must be a primitive value.`);
+    }
+    identity[key] = value;
+  }
+  return identity;
+}
+function stableObject(value) {
+  return JSON.stringify(
+    Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)))
+  );
+}
+function assertSameProperties(left, right, key, sourceChunkIds, nextChunkId) {
+  if (stableObject(left) !== stableObject(right)) {
+    throw new GraphFactConflictError(key, [...sourceChunkIds, nextChunkId]);
+  }
+}
+var GraphFactConflictError = class extends Error {
+  constructor(factKey, sourceChunkIds) {
+    super(
+      `Conflicting graph fact ${factKey} was extracted from chunks ${sourceChunkIds.join(", ")}.`
+    );
+    this.factKey = factKey;
+    this.sourceChunkIds = sourceChunkIds;
+    this.name = "GraphFactConflictError";
+  }
+  factKey;
+  sourceChunkIds;
+};
+function assertConcurrency(value) {
+  if (value !== void 0 && (!Number.isSafeInteger(value) || value < 1)) {
+    throw new RangeError("Graph extraction concurrency must be a positive safe integer.");
+  }
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted !== true) return;
+  if (signal.reason instanceof Error) throw signal.reason;
+  throw new DOMException("The operation was aborted.", "AbortError");
+}
+async function mapConcurrent(values, concurrency, run) {
+  const output = Array(values.length);
+  let cursor = 0;
+  await Promise.all(
+    Array.from({ length: Math.min(concurrency, values.length) }, async () => {
+      for (; ; ) {
+        const index = cursor;
+        cursor += 1;
+        if (index >= values.length) return;
+        output[index] = await run(values[index]);
+      }
+    })
+  );
+  return output;
+}
+
+// src/tool.ts
+import { createTool } from "@anvia/core/tool";
+import { z as z3 } from "zod";
+var primitive = z3.union([z3.string(), z3.number().finite(), z3.boolean()]);
+var propertyValue = z3.union([
+  primitive,
+  z3.array(z3.string()),
+  z3.array(z3.number().finite()),
+  z3.array(z3.boolean())
+]);
+var properties = z3.record(z3.string(), propertyValue);
+var contextSchema = z3.object({
+  seeds: z3.array(
+    z3.object({
+      key: z3.string(),
+      type: z3.string(),
+      score: z3.number().finite(),
+      properties,
+      sourceChunkIds: z3.array(z3.string())
+    })
+  ),
+  nodes: z3.array(
+    z3.object({
+      key: z3.string(),
+      type: z3.string(),
+      identity: z3.record(z3.string(), primitive),
+      properties,
+      sourceChunkIds: z3.array(z3.string())
+    })
+  ),
+  relationships: z3.array(
+    z3.object({
+      key: z3.string(),
+      type: z3.string(),
+      from: z3.string(),
+      to: z3.string(),
+      properties,
+      sourceChunkIds: z3.array(z3.string())
+    })
+  ),
+  evidence: z3.array(
+    z3.object({
+      chunkId: z3.string(),
+      documentId: z3.string(),
+      index: z3.number().int(),
+      text: z3.string(),
+      metadata: properties
+    })
+  )
+});
+function createGraphSearchTool(options) {
+  return createTool({
+    name: options.name,
+    description: options.description,
+    inputSchema: z3.object({
+      query: z3.string().min(1).describe("The question or concept to search for in the graph.")
+    }),
+    outputSchema: contextSchema,
+    execute: async ({ query }, context) => await options.graph.retrieve({
+      model: options.model,
+      query,
+      search: options.search,
+      traversal: options.traversal,
+      evidence: options.evidence,
+      retries: options.retries,
+      abortSignal: context.abortSignal
+    })
+  });
+}
+export {
+  GraphFactConflictError,
+  assertGraphName,
+  assertGraphPropertyName,
+  createGraphSearchTool,
+  defineGraphSchema,
+  extractGraphFacts,
+  freezeGraphSchema,
+  graphReservedPropertyPrefix,
+  parseGraphProperties,
+  parseGraphPropertyValue,
+  resolveGraphExploreOptions,
+  validateGraphSchemaOptions
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/extract.ts","../src/schema.ts","../src/tool.ts"],"sourcesContent":["import { Usage } from \"@anvia/core\";\nimport { extract } from \"@anvia/core/extractor\";\nimport { z } from \"zod\";\nimport { parseGraphProperties } from \"./schema.js\";\nimport type {\n  ExtractGraphFactsOptions,\n  ExtractGraphFactsResult,\n  GraphEntity,\n  GraphFacts,\n  GraphMention,\n  GraphNodeIdentity,\n  GraphProperties,\n  GraphRelationship,\n  GraphSchemaLike,\n} from \"./types.js\";\n\ntype RawEntity = { ref: string; type: string; properties: Record<string, unknown> };\ntype RawRelationship = {\n  type: string;\n  from: string;\n  to: string;\n  properties: Record<string, unknown>;\n};\ntype RawChunkFacts = { entities: RawEntity[]; relationships: RawRelationship[] };\ntype ChunkExtraction = { chunkId: string; output: RawChunkFacts; usage: Usage };\n\nexport async function extractGraphFacts<\n  Schema extends GraphSchemaLike,\n  Model extends import(\"@anvia/core\").CompletionModel,\n>(options: ExtractGraphFactsOptions<Schema, Model>): Promise<ExtractGraphFactsResult<Schema>> {\n  assertConcurrency(options.concurrency);\n  throwIfAborted(options.abortSignal);\n  const ids = new Set<string>();\n  for (const chunk of options.chunks) {\n    if (ids.has(chunk.id)) throw new TypeError(`Duplicate graph chunk id: ${chunk.id}`);\n    ids.add(chunk.id);\n    if (typeof chunk.text !== \"string\") {\n      throw new TypeError(`Graph chunk ${chunk.id} text must be a string.`);\n    }\n  }\n\n  const outputSchema = extractionSchema(options.schema);\n  const instructions = graphInstructions(options.schema, options.instructions);\n  const extractions = await mapConcurrent(\n    options.chunks,\n    options.concurrency ?? 1,\n    async (chunk): Promise<ChunkExtraction> => {\n      throwIfAborted(options.abortSignal);\n      const result = await extract({\n        model: options.model,\n        text: chunk.text,\n        outputSchema,\n        instructions,\n        retries: options.retries,\n        abortSignal: options.abortSignal,\n      });\n      return { chunkId: chunk.id, output: result.output as RawChunkFacts, usage: result.usage };\n    },\n  );\n  return {\n    output: normalizeFacts(options.schema, extractions),\n    usage: extractions.reduce((usage, item) => Usage.add(usage, item.usage), Usage.empty()),\n  };\n}\n\nfunction extractionSchema(schema: GraphSchemaLike): z.ZodType<RawChunkFacts> {\n  const entities = Object.entries(schema.nodes).map(([type, definition]) =>\n    z.object({ ref: z.string().min(1), type: z.literal(type), properties: definition.properties }),\n  );\n  const relationships = Object.entries(schema.relationships).map(([type, definition]) =>\n    z.object({\n      type: z.literal(type),\n      from: z.string().min(1),\n      to: z.string().min(1),\n      properties: definition.properties,\n    }),\n  );\n  return z.object({\n    entities: z.array(union(entities, z.never())),\n    relationships: z.array(union(relationships, z.never())),\n  }) as unknown as z.ZodType<RawChunkFacts>;\n}\n\nfunction union(items: z.ZodType[], empty: z.ZodType): z.ZodType {\n  if (items.length === 0) return empty;\n  if (items.length === 1) return items[0] as z.ZodType;\n  return z.union(items as [z.ZodType, z.ZodType, ...z.ZodType[]]);\n}\n\nfunction graphInstructions(schema: GraphSchemaLike, extra: string | undefined): string {\n  const nodes = Object.entries(schema.nodes)\n    .map(([type, definition]) => `- ${type}: ${definition.description}`)\n    .join(\"\\n\");\n  const relationships = Object.entries(schema.relationships)\n    .map(\n      ([type, definition]) =>\n        `- ${type}: ${definition.from} -> ${definition.to}. ${definition.description}`,\n    )\n    .join(\"\\n\");\n  return [\n    \"Extract only facts directly supported by the source text.\",\n    \"Give every extracted entity a unique local ref and use those refs as relationship endpoints.\",\n    \"Do not invent entity or relationship types outside the declared schema.\",\n    `Node types:\\n${nodes}`,\n    relationships.length === 0\n      ? \"No relationship types are allowed.\"\n      : `Relationship types:\\n${relationships}`,\n    extra,\n  ]\n    .filter((part): part is string => part !== undefined && part.length > 0)\n    .join(\"\\n\\n\");\n}\n\nfunction normalizeFacts<Schema extends GraphSchemaLike>(\n  schema: Schema,\n  extractions: readonly ChunkExtraction[],\n): GraphFacts<Schema> {\n  const entities = new Map<string, GraphEntity<Schema>>();\n  const relationships = new Map<string, GraphRelationship<Schema>>();\n  const mentions = new Map<string, GraphMention>();\n\n  for (const extraction of extractions) {\n    const refs = new Map<string, GraphEntity<Schema>>();\n    for (const raw of extraction.output.entities) {\n      if (refs.has(raw.ref)) {\n        throw new TypeError(`Duplicate entity ref ${raw.ref} in chunk ${extraction.chunkId}.`);\n      }\n      const definition = schema.nodes[raw.type];\n      if (definition === undefined) throw new TypeError(`Unknown graph entity type: ${raw.type}`);\n      const properties = parseGraphProperties(\n        definition.properties.parse(raw.properties),\n        `entity ${raw.type}`,\n      );\n      const identity = identityFromProperties(definition.identity, properties, raw.type);\n      const key = `${raw.type}:${stableObject(identity)}`;\n      const current = entities.get(key);\n      const next = {\n        key,\n        type: raw.type,\n        identity,\n        properties,\n        sourceChunkIds: [extraction.chunkId],\n      } as unknown as GraphEntity<Schema>;\n      if (current === undefined) {\n        entities.set(key, next);\n        refs.set(raw.ref, next);\n      } else {\n        assertSameProperties(\n          current.properties,\n          properties,\n          key,\n          current.sourceChunkIds,\n          extraction.chunkId,\n        );\n        const merged = {\n          ...current,\n          sourceChunkIds: [...current.sourceChunkIds, extraction.chunkId],\n        } as GraphEntity<Schema>;\n        entities.set(key, merged);\n        refs.set(raw.ref, merged);\n      }\n      mentions.set(`${extraction.chunkId}\\u0000${key}`, {\n        chunkId: extraction.chunkId,\n        entityKey: key,\n      });\n    }\n\n    for (const raw of extraction.output.relationships) {\n      const definition = schema.relationships[raw.type];\n      if (definition === undefined) {\n        throw new TypeError(`Unknown graph relationship type: ${raw.type}`);\n      }\n      const from = refs.get(raw.from);\n      const to = refs.get(raw.to);\n      if (from === undefined || to === undefined) {\n        throw new TypeError(\n          `Relationship ${raw.type} in chunk ${extraction.chunkId} references an unknown entity ref.`,\n        );\n      }\n      if (from.type !== definition.from || to.type !== definition.to) {\n        throw new TypeError(\n          `Relationship ${raw.type} has invalid endpoint types ${from.type} -> ${to.type}.`,\n        );\n      }\n      const properties = parseGraphProperties(\n        definition.properties.parse(raw.properties),\n        `relationship ${raw.type}`,\n      );\n      const identity = identityFromProperties(definition.identity ?? [], properties, raw.type);\n      const key = `${raw.type}:${from.key}->${to.key}:${stableObject(identity)}`;\n      const current = relationships.get(key);\n      const next = {\n        key,\n        type: raw.type,\n        from: from.key,\n        to: to.key,\n        properties,\n        sourceChunkIds: [extraction.chunkId],\n      } as unknown as GraphRelationship<Schema>;\n      if (current === undefined) relationships.set(key, next);\n      else {\n        assertSameProperties(\n          current.properties,\n          properties,\n          key,\n          current.sourceChunkIds,\n          extraction.chunkId,\n        );\n        relationships.set(key, {\n          ...current,\n          sourceChunkIds: [...current.sourceChunkIds, extraction.chunkId],\n        } as GraphRelationship<Schema>);\n      }\n    }\n  }\n  return {\n    entities: [...entities.values()],\n    relationships: [...relationships.values()],\n    mentions: [...mentions.values()],\n  };\n}\n\nfunction identityFromProperties(\n  keys: readonly string[],\n  properties: GraphProperties,\n  type: string,\n): GraphNodeIdentity {\n  const identity: Record<string, string | number | boolean> = {};\n  for (const key of keys) {\n    const value = properties[key];\n    if (\n      value === undefined ||\n      !(typeof value === \"string\" || typeof value === \"number\" || typeof value === \"boolean\")\n    ) {\n      throw new TypeError(`Identity property ${key} for ${type} must be a primitive value.`);\n    }\n    identity[key] = value;\n  }\n  return identity;\n}\n\nfunction stableObject(value: Readonly<Record<string, unknown>>): string {\n  return JSON.stringify(\n    Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right))),\n  );\n}\n\nfunction assertSameProperties(\n  left: GraphProperties,\n  right: GraphProperties,\n  key: string,\n  sourceChunkIds: readonly string[],\n  nextChunkId: string,\n): void {\n  if (stableObject(left) !== stableObject(right)) {\n    throw new GraphFactConflictError(key, [...sourceChunkIds, nextChunkId]);\n  }\n}\n\nexport class GraphFactConflictError extends Error {\n  constructor(\n    readonly factKey: string,\n    readonly sourceChunkIds: readonly string[],\n  ) {\n    super(\n      `Conflicting graph fact ${factKey} was extracted from chunks ${sourceChunkIds.join(\", \")}.`,\n    );\n    this.name = \"GraphFactConflictError\";\n  }\n}\n\nfunction assertConcurrency(value: number | undefined): void {\n  if (value !== undefined && (!Number.isSafeInteger(value) || value < 1)) {\n    throw new RangeError(\"Graph extraction concurrency must be a positive safe integer.\");\n  }\n}\n\nfunction throwIfAborted(signal: AbortSignal | undefined): void {\n  if (signal?.aborted !== true) return;\n  if (signal.reason instanceof Error) throw signal.reason;\n  throw new DOMException(\"The operation was aborted.\", \"AbortError\");\n}\n\nasync function mapConcurrent<Input, Output>(\n  values: readonly Input[],\n  concurrency: number,\n  run: (value: Input) => Promise<Output>,\n): Promise<Output[]> {\n  const output = Array<Output>(values.length);\n  let cursor = 0;\n  await Promise.all(\n    Array.from({ length: Math.min(concurrency, values.length) }, async () => {\n      for (;;) {\n        const index = cursor;\n        cursor += 1;\n        if (index >= values.length) return;\n        output[index] = await run(values[index] as Input);\n      }\n    }),\n  );\n  return output;\n}\n","import { z } from \"zod\";\nimport type {\n  GraphProperties,\n  GraphPropertyPrimitive,\n  GraphPropertyValue,\n  GraphSchema,\n  GraphSchemaOptions,\n} from \"./types.js\";\n\nexport const graphReservedPropertyPrefix = \"__anvia_\";\n\nexport function defineGraphSchema<const Options extends GraphSchemaOptions>(\n  options: Options,\n): GraphSchema<Options> {\n  validateGraphSchemaOptions(options);\n  return freezeGraphSchema(options, \"graph-schema\");\n}\n\nexport function validateGraphSchemaOptions(options: GraphSchemaOptions): void {\n  if (Object.keys(options.nodes).length === 0) {\n    throw new TypeError(\"A graph schema requires at least one node type.\");\n  }\n  for (const [type, definition] of Object.entries(options.nodes)) {\n    assertGraphName(type, \"node type\");\n    assertDescription(definition.description, `node ${type}`);\n    if (!(definition.properties instanceof z.ZodObject)) {\n      throw new TypeError(`Properties for node ${type} must be a Zod object schema.`);\n    }\n    assertExactPropertySchema(definition.properties, `node ${type}`);\n    if (\n      definition.identity.length === 0 ||\n      new Set(definition.identity).size !== definition.identity.length\n    ) {\n      throw new TypeError(`Node ${type} must declare unique identity properties.`);\n    }\n    for (const property of definition.identity) {\n      assertGraphPropertyName(property);\n      if (!(property in definition.properties.shape)) {\n        throw new TypeError(`Identity property ${property} is not declared by node ${type}.`);\n      }\n    }\n    for (const property of Object.keys(definition.properties.shape)) {\n      assertGraphPropertyName(property);\n    }\n  }\n  for (const [type, definition] of Object.entries(options.relationships)) {\n    assertGraphName(type, \"relationship type\");\n    assertDescription(definition.description, `relationship ${type}`);\n    if (!(definition.from in options.nodes) || !(definition.to in options.nodes)) {\n      throw new TypeError(`Relationship ${type} references an unknown endpoint type.`);\n    }\n    if (!(definition.properties instanceof z.ZodObject)) {\n      throw new TypeError(`Properties for relationship ${type} must be a Zod object schema.`);\n    }\n    assertExactPropertySchema(definition.properties, `relationship ${type}`);\n    const identity = definition.identity ?? [];\n    if (new Set(identity).size !== identity.length) {\n      throw new TypeError(`Relationship ${type} contains duplicate identity properties.`);\n    }\n    for (const property of Object.keys(definition.properties.shape)) {\n      assertGraphPropertyName(property);\n    }\n    for (const property of identity) {\n      if (!(property in definition.properties.shape)) {\n        throw new TypeError(\n          `Identity property ${property} is not declared by relationship ${type}.`,\n        );\n      }\n    }\n  }\n}\n\nexport function freezeGraphSchema<\n  const Options extends GraphSchemaOptions,\n  const Kind extends string,\n>(options: Options, kind: Kind): Readonly<Options & { kind: Kind }> {\n  const nodes = Object.fromEntries(\n    Object.entries(options.nodes).map(([type, definition]) => [\n      type,\n      Object.freeze({ ...definition, identity: Object.freeze([...definition.identity]) }),\n    ]),\n  );\n  const relationships = Object.fromEntries(\n    Object.entries(options.relationships).map(([type, definition]) => {\n      const copy = { ...definition };\n      if (definition.identity !== undefined) {\n        Object.assign(copy, { identity: Object.freeze([...definition.identity]) });\n      }\n      return [type, Object.freeze(copy)];\n    }),\n  );\n  return Object.freeze({\n    nodes: Object.freeze(nodes),\n    relationships: Object.freeze(relationships),\n    kind,\n  }) as Readonly<Options & { kind: Kind }>;\n}\n\nexport function parseGraphProperties(value: unknown, label: string): GraphProperties {\n  if (typeof value !== \"object\" || value === null || Array.isArray(value)) {\n    throw new TypeError(`${label} must be an object of graph property values.`);\n  }\n  const output: Record<string, GraphPropertyValue> = {};\n  for (const [key, item] of Object.entries(value)) {\n    assertGraphPropertyName(key);\n    output[key] = parseGraphPropertyValue(item, `${label}.${key}`);\n  }\n  return output;\n}\n\nexport function parseGraphPropertyValue(value: unknown, label: string): GraphPropertyValue {\n  if (typeof value === \"string\" || typeof value === \"boolean\") return value;\n  if (typeof value === \"number\") {\n    if (!Number.isFinite(value)) throw new TypeError(`${label} must be finite.`);\n    if (Number.isInteger(value) && !Number.isSafeInteger(value)) {\n      throw new TypeError(`${label} must be a safe integer.`);\n    }\n    return value;\n  }\n  if (Array.isArray(value)) {\n    if (value.length === 0) return [];\n    const parsed = value.map((item, index) => parsePrimitive(item, `${label}[${index}]`));\n    const type = typeof parsed[0];\n    if (!parsed.every((item) => typeof item === type)) {\n      throw new TypeError(`${label} must be a homogeneous array.`);\n    }\n    return parsed as GraphPropertyValue;\n  }\n  throw new TypeError(`${label} is not a supported graph property value.`);\n}\n\nexport function assertGraphName(value: string, label: string): void {\n  if (typeof value !== \"string\" || value.length === 0) {\n    throw new TypeError(`${label} must be a non-empty string.`);\n  }\n}\n\nexport function assertGraphPropertyName(value: string): void {\n  assertGraphName(value, \"graph property name\");\n  if (value.startsWith(graphReservedPropertyPrefix)) {\n    throw new TypeError(\n      `Graph property names beginning with ${graphReservedPropertyPrefix} are reserved.`,\n    );\n  }\n}\n\nfunction parsePrimitive(value: unknown, label: string): GraphPropertyPrimitive {\n  const parsed = parseGraphPropertyValue(value, label);\n  if (typeof parsed === \"string\" || typeof parsed === \"number\" || typeof parsed === \"boolean\") {\n    return parsed;\n  }\n  throw new TypeError(`${label} must be a primitive property value.`);\n}\n\nfunction assertDescription(value: string, label: string): void {\n  if (typeof value !== \"string\" || value.trim().length === 0) {\n    throw new TypeError(`${label} requires a non-empty description.`);\n  }\n}\n\nfunction assertExactPropertySchema(schema: z.ZodObject<z.ZodRawShape>, label: string): void {\n  const definition = schema._zod.def;\n  if (!(definition.catchall instanceof z.ZodNever)) {\n    throw new TypeError(`${label} properties must use a strict Zod object schema.`);\n  }\n  for (const [property, propertySchema] of Object.entries(schema.shape)) {\n    assertNonEffectfulSchema(propertySchema, `${label} property ${property}`, new Set());\n  }\n}\n\nfunction assertNonEffectfulSchema(value: unknown, label: string, visited: Set<z.ZodType>): void {\n  if (!(value instanceof z.ZodType)) throw new TypeError(`${label} must be a Zod schema.`);\n  if (visited.has(value)) return;\n  visited.add(value);\n  const definition = value._zod.def as unknown as Record<string, unknown>;\n  const type = definition.type;\n  if (\n    definition.coerce === true ||\n    type === \"default\" ||\n    type === \"prefault\" ||\n    type === \"catch\" ||\n    type === \"transform\" ||\n    type === \"pipe\"\n  ) {\n    throw new TypeError(\n      `${label} must not coerce, default, transform, preprocess, or catch values.`,\n    );\n  }\n  const checks = definition.checks;\n  if (\n    Array.isArray(checks) &&\n    checks.some((check) => {\n      if (typeof check !== \"object\" || check === null) return false;\n      return (check as { _zod?: { def?: { check?: unknown } } })._zod?.def?.check === \"overwrite\";\n    })\n  ) {\n    throw new TypeError(`${label} must not normalize or overwrite values.`);\n  }\n  for (const child of schemaChildren(definition)) assertNonEffectfulSchema(child, label, visited);\n}\n\nfunction schemaChildren(definition: Record<string, unknown>): z.ZodType[] {\n  const children: z.ZodType[] = [];\n  for (const key of [\"innerType\", \"element\", \"left\", \"right\", \"rest\", \"keyType\", \"valueType\"]) {\n    const value = definition[key];\n    if (value instanceof z.ZodType) children.push(value);\n  }\n  for (const key of [\"options\", \"items\"]) {\n    const value = definition[key];\n    if (Array.isArray(value)) {\n      for (const item of value) if (item instanceof z.ZodType) children.push(item);\n    }\n  }\n  return children;\n}\n","import { createTool } from \"@anvia/core/tool\";\nimport { z } from \"zod\";\nimport type {\n  CreateGraphSearchToolOptions,\n  GraphContextRetriever,\n  GraphSchemaLike,\n  GraphSearchTool,\n} from \"./types.js\";\n\nconst primitive = z.union([z.string(), z.number().finite(), z.boolean()]);\nconst propertyValue = z.union([\n  primitive,\n  z.array(z.string()),\n  z.array(z.number().finite()),\n  z.array(z.boolean()),\n]);\nconst properties = z.record(z.string(), propertyValue);\nconst contextSchema = z.object({\n  seeds: z.array(\n    z.object({\n      key: z.string(),\n      type: z.string(),\n      score: z.number().finite(),\n      properties,\n      sourceChunkIds: z.array(z.string()),\n    }),\n  ),\n  nodes: z.array(\n    z.object({\n      key: z.string(),\n      type: z.string(),\n      identity: z.record(z.string(), primitive),\n      properties,\n      sourceChunkIds: z.array(z.string()),\n    }),\n  ),\n  relationships: z.array(\n    z.object({\n      key: z.string(),\n      type: z.string(),\n      from: z.string(),\n      to: z.string(),\n      properties,\n      sourceChunkIds: z.array(z.string()),\n    }),\n  ),\n  evidence: z.array(\n    z.object({\n      chunkId: z.string(),\n      documentId: z.string(),\n      index: z.number().int(),\n      text: z.string(),\n      metadata: properties,\n    }),\n  ),\n});\n\nexport function createGraphSearchTool<\n  Schema extends GraphSchemaLike,\n  Retriever extends GraphContextRetriever<Schema>,\n>(options: CreateGraphSearchToolOptions<Schema, Retriever>): GraphSearchTool {\n  return createTool({\n    name: options.name,\n    description: options.description,\n    inputSchema: z.object({\n      query: z.string().min(1).describe(\"The question or concept to search for in the graph.\"),\n    }),\n    outputSchema: contextSchema,\n    execute: async ({ query }, context) =>\n      (await options.graph.retrieve({\n        model: options.model,\n        query,\n        search: options.search,\n        traversal: options.traversal,\n        evidence: options.evidence,\n        retries: options.retries,\n        abortSignal: context.abortSignal,\n      })) as unknown as z.input<typeof contextSchema>,\n  }) as unknown as GraphSearchTool;\n}\n"],"mappings":"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","names":["z","z","properties","z"]}

package/package.json

@@ -1,15 +1,50 @@
 {
   "name": "@anvia/graph",
-  "version": "0.0.0-bootstrap.0",
-  "description": "Reserved for the Anvia graph package.",
+  "version": "1.0.3",
+  "description": "Provider-neutral knowledge graph primitives for Anvia.",
+  "author": "anvia",
+  "maintainer": "Indra Zulfi",
   "license": "MIT",
-  "type": "module",
   "repository": {
     "type": "git",
-    "url": "https://github.com/anvia-hq/anvia.git",
+    "url": "https://github.com/anvia-hq/anvia",
     "directory": "packages/graph"
   },
+  "files": [
+    "dist"
+  ],
   "publishConfig": {
     "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./explore": {
+      "types": "./dist/explore.d.ts",
+      "import": "./dist/explore.js"
+    }
+  },
+  "dependencies": {
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/node": "^24.9.1",
+    "tsup": "^8.5.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.8",
+    "@anvia/core": "1.0.2"
+  },
+  "peerDependencies": {
+    "@anvia/core": "1.0.2"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/explore.ts --format esm --dts --sourcemap --clean",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
   }
-}
+}

package/index.js

@@ -1 +0,0 @@
-export {};