@yolk-sdk/knowledge 0.0.1-canary.0

package/dist/documents.mjs

@@ -0,0 +1,93 @@
+import { Schema } from "effect";
+//#region src/documents.ts
+const NonEmptyTrimmedString = Schema.Trimmed.pipe(Schema.check(Schema.isNonEmpty()));
+const PositiveInteger = Schema.Int.pipe(Schema.check(Schema.isGreaterThan(0)));
+const NonNegativeInteger = Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0)));
+const KnowledgeMetadataSchema = Schema.Record(Schema.String, Schema.Unknown);
+const KnowledgeDocumentStatusSchema = Schema.Literals([
+	"pending",
+	"processing",
+	"ready",
+	"error"
+]);
+const KnowledgeSourceSchema = Schema.Union([
+	Schema.Struct({
+		_tag: Schema.Literal("File"),
+		ref: NonEmptyTrimmedString,
+		name: Schema.optional(NonEmptyTrimmedString),
+		mediaType: Schema.optional(NonEmptyTrimmedString)
+	}),
+	Schema.Struct({
+		_tag: Schema.Literal("Url"),
+		url: NonEmptyTrimmedString
+	}),
+	Schema.Struct({
+		_tag: Schema.Literal("Text"),
+		label: Schema.optional(NonEmptyTrimmedString)
+	})
+]);
+const KnowledgeEmbeddingConfigSchema = Schema.Struct({
+	model: NonEmptyTrimmedString,
+	dimensions: PositiveInteger
+});
+const KnowledgeChunkingConfigSchema = Schema.Struct({
+	strategy: Schema.Literal("sentence-token"),
+	maxTokens: PositiveInteger
+});
+const KnowledgeCollectionSchema = Schema.Struct({
+	id: NonEmptyTrimmedString,
+	label: Schema.optional(NonEmptyTrimmedString),
+	embeddingConfig: KnowledgeEmbeddingConfigSchema,
+	chunkingConfig: KnowledgeChunkingConfigSchema,
+	metadata: Schema.optional(KnowledgeMetadataSchema)
+});
+const KnowledgeDocumentSchema = Schema.Struct({
+	id: NonEmptyTrimmedString,
+	collectionId: NonEmptyTrimmedString,
+	source: KnowledgeSourceSchema,
+	status: KnowledgeDocumentStatusSchema,
+	title: Schema.optional(NonEmptyTrimmedString),
+	summary: Schema.optional(Schema.String),
+	errorMessage: Schema.optional(Schema.String),
+	contentHash: Schema.optional(NonEmptyTrimmedString),
+	tokenCount: Schema.optional(NonNegativeInteger),
+	chunkCount: Schema.optional(NonNegativeInteger),
+	metadata: Schema.optional(KnowledgeMetadataSchema)
+});
+const KnowledgeChunkSchema = Schema.Struct({
+	id: NonEmptyTrimmedString,
+	collectionId: NonEmptyTrimmedString,
+	documentId: NonEmptyTrimmedString,
+	content: NonEmptyTrimmedString,
+	position: NonNegativeInteger,
+	tokenCount: PositiveInteger,
+	metadata: Schema.optional(KnowledgeMetadataSchema)
+});
+const ExtractedKnowledgeDocumentSchema = Schema.Struct({
+	content: NonEmptyTrimmedString,
+	title: Schema.optional(NonEmptyTrimmedString),
+	summary: Schema.optional(Schema.String),
+	metadata: Schema.optional(KnowledgeMetadataSchema)
+});
+const KnowledgeSearchScopeSchema = Schema.Union([Schema.Struct({
+	_tag: Schema.Literal("KnowledgeCollection"),
+	id: NonEmptyTrimmedString
+}), Schema.Struct({
+	_tag: Schema.Literal("KnowledgeCollections"),
+	ids: Schema.Array(NonEmptyTrimmedString)
+})]);
+const defaultKnowledgeChunkingConfig = {
+	strategy: "sentence-token",
+	maxTokens: 512
+};
+const makeKnowledgeCollection = (input) => ({
+	id: input.id,
+	label: input.label,
+	embeddingConfig: input.embeddingConfig,
+	chunkingConfig: input.chunkingConfig ?? defaultKnowledgeChunkingConfig,
+	metadata: input.metadata
+});
+//#endregion
+export { ExtractedKnowledgeDocumentSchema, KnowledgeChunkSchema, KnowledgeChunkingConfigSchema, KnowledgeCollectionSchema, KnowledgeDocumentSchema, KnowledgeDocumentStatusSchema, KnowledgeEmbeddingConfigSchema, KnowledgeMetadataSchema, KnowledgeSearchScopeSchema, KnowledgeSourceSchema, defaultKnowledgeChunkingConfig, makeKnowledgeCollection };
+
+//# sourceMappingURL=documents.mjs.map

package/dist/documents.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"documents.mjs","names":[],"sources":["../src/documents.ts"],"sourcesContent":["import { Schema } from 'effect'\n\nconst NonEmptyTrimmedString = Schema.Trimmed.pipe(Schema.check(Schema.isNonEmpty()))\nconst PositiveInteger = Schema.Int.pipe(Schema.check(Schema.isGreaterThan(0)))\nconst NonNegativeInteger = Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0)))\n\nexport const KnowledgeMetadataSchema = Schema.Record(Schema.String, Schema.Unknown)\nexport type KnowledgeMetadata = Schema.Schema.Type<typeof KnowledgeMetadataSchema>\n\nexport const KnowledgeDocumentStatusSchema = Schema.Literals(['pending', 'processing', 'ready', 'error'])\nexport type KnowledgeDocumentStatus = Schema.Schema.Type<typeof KnowledgeDocumentStatusSchema>\n\nexport const KnowledgeSourceSchema = Schema.Union([\n  Schema.Struct({\n    _tag: Schema.Literal('File'),\n    ref: NonEmptyTrimmedString,\n    name: Schema.optional(NonEmptyTrimmedString),\n    mediaType: Schema.optional(NonEmptyTrimmedString)\n  }),\n  Schema.Struct({\n    _tag: Schema.Literal('Url'),\n    url: NonEmptyTrimmedString\n  }),\n  Schema.Struct({\n    _tag: Schema.Literal('Text'),\n    label: Schema.optional(NonEmptyTrimmedString)\n  })\n])\nexport type KnowledgeSource = Schema.Schema.Type<typeof KnowledgeSourceSchema>\n\nexport const KnowledgeEmbeddingConfigSchema = Schema.Struct({\n  model: NonEmptyTrimmedString,\n  dimensions: PositiveInteger\n})\nexport type KnowledgeEmbeddingConfig = Schema.Schema.Type<typeof KnowledgeEmbeddingConfigSchema>\n\nexport const KnowledgeChunkingConfigSchema = Schema.Struct({\n  strategy: Schema.Literal('sentence-token'),\n  maxTokens: PositiveInteger\n})\nexport type KnowledgeChunkingConfig = Schema.Schema.Type<typeof KnowledgeChunkingConfigSchema>\n\nexport const KnowledgeCollectionSchema = Schema.Struct({\n  id: NonEmptyTrimmedString,\n  label: Schema.optional(NonEmptyTrimmedString),\n  embeddingConfig: KnowledgeEmbeddingConfigSchema,\n  chunkingConfig: KnowledgeChunkingConfigSchema,\n  metadata: Schema.optional(KnowledgeMetadataSchema)\n})\nexport type KnowledgeCollection = Schema.Schema.Type<typeof KnowledgeCollectionSchema>\n\nexport const KnowledgeDocumentSchema = Schema.Struct({\n  id: NonEmptyTrimmedString,\n  collectionId: NonEmptyTrimmedString,\n  source: KnowledgeSourceSchema,\n  status: KnowledgeDocumentStatusSchema,\n  title: Schema.optional(NonEmptyTrimmedString),\n  summary: Schema.optional(Schema.String),\n  errorMessage: Schema.optional(Schema.String),\n  contentHash: Schema.optional(NonEmptyTrimmedString),\n  tokenCount: Schema.optional(NonNegativeInteger),\n  chunkCount: Schema.optional(NonNegativeInteger),\n  metadata: Schema.optional(KnowledgeMetadataSchema)\n})\nexport type KnowledgeDocument = Schema.Schema.Type<typeof KnowledgeDocumentSchema>\n\nexport const KnowledgeChunkSchema = Schema.Struct({\n  id: NonEmptyTrimmedString,\n  collectionId: NonEmptyTrimmedString,\n  documentId: NonEmptyTrimmedString,\n  content: NonEmptyTrimmedString,\n  position: NonNegativeInteger,\n  tokenCount: PositiveInteger,\n  metadata: Schema.optional(KnowledgeMetadataSchema)\n})\nexport type KnowledgeChunk = Schema.Schema.Type<typeof KnowledgeChunkSchema>\n\nexport const ExtractedKnowledgeDocumentSchema = Schema.Struct({\n  content: NonEmptyTrimmedString,\n  title: Schema.optional(NonEmptyTrimmedString),\n  summary: Schema.optional(Schema.String),\n  metadata: Schema.optional(KnowledgeMetadataSchema)\n})\nexport type ExtractedKnowledgeDocument = Schema.Schema.Type<typeof ExtractedKnowledgeDocumentSchema>\n\nexport const KnowledgeSearchScopeSchema = Schema.Union([\n  Schema.Struct({ _tag: Schema.Literal('KnowledgeCollection'), id: NonEmptyTrimmedString }),\n  Schema.Struct({ _tag: Schema.Literal('KnowledgeCollections'), ids: Schema.Array(NonEmptyTrimmedString) })\n])\nexport type KnowledgeSearchScope = Schema.Schema.Type<typeof KnowledgeSearchScopeSchema>\n\nexport const defaultKnowledgeChunkingConfig: KnowledgeChunkingConfig = {\n  strategy: 'sentence-token',\n  maxTokens: 512\n}\n\nexport const makeKnowledgeCollection = (input: {\n  readonly id: string\n  readonly label?: string\n  readonly embeddingConfig: KnowledgeEmbeddingConfig\n  readonly chunkingConfig?: KnowledgeChunkingConfig\n  readonly metadata?: KnowledgeMetadata\n}): KnowledgeCollection => ({\n  id: input.id,\n  label: input.label,\n  embeddingConfig: input.embeddingConfig,\n  chunkingConfig: input.chunkingConfig ?? defaultKnowledgeChunkingConfig,\n  metadata: input.metadata\n})\n"],"mappings":";;AAEA,MAAM,wBAAwB,OAAO,QAAQ,KAAK,OAAO,MAAM,OAAO,WAAW,CAAC,CAAC;AACnF,MAAM,kBAAkB,OAAO,IAAI,KAAK,OAAO,MAAM,OAAO,cAAc,CAAC,CAAC,CAAC;AAC7E,MAAM,qBAAqB,OAAO,IAAI,KAAK,OAAO,MAAM,OAAO,uBAAuB,CAAC,CAAC,CAAC;AAEzF,MAAa,0BAA0B,OAAO,OAAO,OAAO,QAAQ,OAAO,OAAO;AAGlF,MAAa,gCAAgC,OAAO,SAAS;CAAC;CAAW;CAAc;CAAS;AAAO,CAAC;AAGxG,MAAa,wBAAwB,OAAO,MAAM;CAChD,OAAO,OAAO;EACZ,MAAM,OAAO,QAAQ,MAAM;EAC3B,KAAK;EACL,MAAM,OAAO,SAAS,qBAAqB;EAC3C,WAAW,OAAO,SAAS,qBAAqB;CAClD,CAAC;CACD,OAAO,OAAO;EACZ,MAAM,OAAO,QAAQ,KAAK;EAC1B,KAAK;CACP,CAAC;CACD,OAAO,OAAO;EACZ,MAAM,OAAO,QAAQ,MAAM;EAC3B,OAAO,OAAO,SAAS,qBAAqB;CAC9C,CAAC;AACH,CAAC;AAGD,MAAa,iCAAiC,OAAO,OAAO;CAC1D,OAAO;CACP,YAAY;AACd,CAAC;AAGD,MAAa,gCAAgC,OAAO,OAAO;CACzD,UAAU,OAAO,QAAQ,gBAAgB;CACzC,WAAW;AACb,CAAC;AAGD,MAAa,4BAA4B,OAAO,OAAO;CACrD,IAAI;CACJ,OAAO,OAAO,SAAS,qBAAqB;CAC5C,iBAAiB;CACjB,gBAAgB;CAChB,UAAU,OAAO,SAAS,uBAAuB;AACnD,CAAC;AAGD,MAAa,0BAA0B,OAAO,OAAO;CACnD,IAAI;CACJ,cAAc;CACd,QAAQ;CACR,QAAQ;CACR,OAAO,OAAO,SAAS,qBAAqB;CAC5C,SAAS,OAAO,SAAS,OAAO,MAAM;CACtC,cAAc,OAAO,SAAS,OAAO,MAAM;CAC3C,aAAa,OAAO,SAAS,qBAAqB;CAClD,YAAY,OAAO,SAAS,kBAAkB;CAC9C,YAAY,OAAO,SAAS,kBAAkB;CAC9C,UAAU,OAAO,SAAS,uBAAuB;AACnD,CAAC;AAGD,MAAa,uBAAuB,OAAO,OAAO;CAChD,IAAI;CACJ,cAAc;CACd,YAAY;CACZ,SAAS;CACT,UAAU;CACV,YAAY;CACZ,UAAU,OAAO,SAAS,uBAAuB;AACnD,CAAC;AAGD,MAAa,mCAAmC,OAAO,OAAO;CAC5D,SAAS;CACT,OAAO,OAAO,SAAS,qBAAqB;CAC5C,SAAS,OAAO,SAAS,OAAO,MAAM;CACtC,UAAU,OAAO,SAAS,uBAAuB;AACnD,CAAC;AAGD,MAAa,6BAA6B,OAAO,MAAM,CACrD,OAAO,OAAO;CAAE,MAAM,OAAO,QAAQ,qBAAqB;CAAG,IAAI;AAAsB,CAAC,GACxF,OAAO,OAAO;CAAE,MAAM,OAAO,QAAQ,sBAAsB;CAAG,KAAK,OAAO,MAAM,qBAAqB;AAAE,CAAC,CAC1G,CAAC;AAGD,MAAa,iCAA0D;CACrE,UAAU;CACV,WAAW;AACb;AAEA,MAAa,2BAA2B,WAMZ;CAC1B,IAAI,MAAM;CACV,OAAO,MAAM;CACb,iBAAiB,MAAM;CACvB,gBAAgB,MAAM,kBAAkB;CACxC,UAAU,MAAM;AAClB"}

package/dist/embeddings.d.mts

@@ -0,0 +1,14 @@
+import { KnowledgeEmbeddingError } from "./errors.mjs";
+import { Context, Effect } from "effect";
+
+//#region src/embeddings.d.ts
+type KnowledgeEmbedding = ReadonlyArray<number>;
+type KnowledgeEmbedderApi = {
+  readonly embedTexts: (texts: ReadonlyArray<string>) => Effect.Effect<ReadonlyArray<KnowledgeEmbedding>, KnowledgeEmbeddingError>;
+  readonly embedQuery: (query: string) => Effect.Effect<KnowledgeEmbedding, KnowledgeEmbeddingError>;
+};
+declare const KnowledgeEmbedder_base: Context.ServiceClass<KnowledgeEmbedder, "@yolk-sdk/knowledge/KnowledgeEmbedder", KnowledgeEmbedderApi>;
+declare class KnowledgeEmbedder extends KnowledgeEmbedder_base {}
+//#endregion
+export { KnowledgeEmbeddingError as EmbedderError, KnowledgeEmbedder, KnowledgeEmbedderApi, KnowledgeEmbedding };
+//# sourceMappingURL=embeddings.d.mts.map

package/dist/embeddings.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embeddings.d.mts","names":[],"sources":["../src/embeddings.ts"],"mappings":";;;;KAIY,kBAAA,GAAqB,aAAa;AAAA,KAElC,oBAAA;EAAA,SACD,UAAA,GACP,KAAA,EAAO,aAAA,aACJ,MAAA,CAAO,MAAA,CAAO,aAAA,CAAc,kBAAA,GAAqB,uBAAA;EAAA,SAC7C,UAAA,GAAa,KAAA,aAAkB,MAAA,CAAO,MAAA,CAAO,kBAAA,EAAoB,uBAAA;AAAA;AAAA,cAC3E,sBAAA;cAEY,iBAAA,SAA0B,sBAEtC"}

package/dist/embeddings.mjs

@@ -0,0 +1,8 @@
+import { KnowledgeEmbeddingError } from "./errors.mjs";
+import { Context } from "effect";
+//#region src/embeddings.ts
+var KnowledgeEmbedder = class extends Context.Service()("@yolk-sdk/knowledge/KnowledgeEmbedder") {};
+//#endregion
+export { KnowledgeEmbeddingError as EmbedderError, KnowledgeEmbedder };
+
+//# sourceMappingURL=embeddings.mjs.map

package/dist/embeddings.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"embeddings.mjs","names":[],"sources":["../src/embeddings.ts"],"sourcesContent":["import { Context } from 'effect'\nimport type { Effect } from 'effect'\nimport type { KnowledgeEmbeddingError } from './errors.ts'\n\nexport type KnowledgeEmbedding = ReadonlyArray<number>\n\nexport type KnowledgeEmbedderApi = {\n  readonly embedTexts: (\n    texts: ReadonlyArray<string>\n  ) => Effect.Effect<ReadonlyArray<KnowledgeEmbedding>, KnowledgeEmbeddingError>\n  readonly embedQuery: (query: string) => Effect.Effect<KnowledgeEmbedding, KnowledgeEmbeddingError>\n}\n\nexport class KnowledgeEmbedder extends Context.Service<KnowledgeEmbedder, KnowledgeEmbedderApi>()(\n  '@yolk-sdk/knowledge/KnowledgeEmbedder'\n) {}\n\nexport { KnowledgeEmbeddingError as EmbedderError } from './errors.ts'\n"],"mappings":";;;AAaA,IAAa,oBAAb,cAAuC,QAAQ,QAAiD,EAC9F,uCACF,EAAE,CAAC"}

package/dist/errors.d.mts

@@ -0,0 +1,72 @@
+import * as Schema from "effect/Schema";
+
+//#region src/errors.d.ts
+declare const SearchIndexStoreError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "SearchIndexStoreError";
+} & Readonly<A>;
+declare class SearchIndexStoreError extends SearchIndexStoreError_base<{
+  readonly message: string;
+  readonly cause?: unknown;
+}> {}
+declare const KnowledgeExtractionError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "KnowledgeExtractionError";
+} & Readonly<A>;
+declare class KnowledgeExtractionError extends KnowledgeExtractionError_base<{
+  readonly message: string;
+  readonly cause?: unknown;
+}> {}
+declare const KnowledgeChunkingError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "KnowledgeChunkingError";
+} & Readonly<A>;
+declare class KnowledgeChunkingError extends KnowledgeChunkingError_base<{
+  readonly message: string;
+  readonly cause?: unknown;
+}> {}
+declare const KnowledgeEmbeddingError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "KnowledgeEmbeddingError";
+} & Readonly<A>;
+declare class KnowledgeEmbeddingError extends KnowledgeEmbeddingError_base<{
+  readonly message: string;
+  readonly cause?: unknown;
+}> {}
+declare const KnowledgeSummarizationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "KnowledgeSummarizationError";
+} & Readonly<A>;
+declare class KnowledgeSummarizationError extends KnowledgeSummarizationError_base<{
+  readonly message: string;
+  readonly cause?: unknown;
+}> {}
+declare const KnowledgeIngestionError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "KnowledgeIngestionError";
+} & Readonly<A>;
+declare class KnowledgeIngestionError extends KnowledgeIngestionError_base<{
+  readonly message: string;
+  readonly stage: 'store' | 'extract' | 'chunk' | 'embed' | 'summarize';
+  readonly cause?: unknown;
+}> {}
+declare const KnowledgeSearchError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "KnowledgeSearchError";
+} & Readonly<A>;
+declare class KnowledgeSearchError extends KnowledgeSearchError_base<{
+  readonly message: string;
+  readonly stage: 'store' | 'embed';
+  readonly cause?: unknown;
+}> {}
+declare const KnowledgeStoreError_base: Schema.Class<KnowledgeStoreError, Schema.TaggedStruct<"KnowledgeStoreError", {
+  readonly message: Schema.String;
+  readonly cause: Schema.optional<Schema.Unknown>;
+}>, import("effect/Cause").YieldableError>;
+declare class KnowledgeStoreError extends KnowledgeStoreError_base {}
+declare const KnowledgeArtifactError_base: Schema.Class<KnowledgeArtifactError, Schema.TaggedStruct<"KnowledgeArtifactError", {
+  readonly message: Schema.String;
+  readonly cause: Schema.optional<Schema.Unknown>;
+}>, import("effect/Cause").YieldableError>;
+declare class KnowledgeArtifactError extends KnowledgeArtifactError_base {}
+declare const KnowledgeContextError_base: Schema.Class<KnowledgeContextError, Schema.TaggedStruct<"KnowledgeContextError", {
+  readonly message: Schema.String;
+  readonly cause: Schema.optional<Schema.Unknown>;
+}>, import("effect/Cause").YieldableError>;
+declare class KnowledgeContextError extends KnowledgeContextError_base {}
+//#endregion
+export { KnowledgeArtifactError, KnowledgeChunkingError, KnowledgeContextError, KnowledgeEmbeddingError, KnowledgeExtractionError, KnowledgeIngestionError, KnowledgeSearchError, KnowledgeStoreError, KnowledgeSummarizationError, SearchIndexStoreError };
+//# sourceMappingURL=errors.d.mts.map

package/dist/errors.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.mts","names":[],"sources":["../src/errors.ts"],"mappings":";;;cACuC,0BAAA;;;cAE1B,qBAAA,SAA8B,0BAAA;EAAA,SAChC,OAAA;EAAA,SACA,KAAA;AAAA;AAAA,cACN,6BAAA;;;cAEQ,wBAAA,SAAiC,6BAAA;EAAA,SACnC,OAAA;EAAA,SACA,KAAA;AAAA;AAAA,cACN,2BAAA;;;cAEQ,sBAAA,SAA+B,2BAAA;EAAA,SACjC,OAAA;EAAA,SACA,KAAA;AAAA;AAAA,cACN,4BAAA;;;cAEQ,uBAAA,SAAgC,4BAAA;EAAA,SAClC,OAAA;EAAA,SACA,KAAA;AAAA;AAAA,cACN,gCAAA;;;cAEQ,2BAAA,SAAoC,gCAAA;EAAA,SACtC,OAAA;EAAA,SACA,KAAA;AAAA;AAAA,cACN,4BAAA;;;cAEQ,uBAAA,SAAgC,4BAAA;EAAA,SAClC,OAAA;EAAA,SACA,KAAA;EAAA,SACA,KAAA;AAAA;AAAA,cACN,yBAAA;;;cAEQ,oBAAA,SAA6B,yBAAA;EAAA,SAC/B,OAAA;EAAA,SACA,KAAA;EAAA,SACA,KAAA;AAAA;AAAA,cACN,wBAAA;;;;cAEQ,mBAAA,SAA4B,wBAMxC;AAAA,cAAG,2BAAA;;;;cAES,sBAAA,SAA+B,2BAM3C;AAAA,cAAG,0BAAA;;;;cAES,qBAAA,SAA8B,0BAM1C"}

package/dist/errors.mjs

@@ -0,0 +1,26 @@
+import { Data } from "effect";
+import * as Schema$1 from "effect/Schema";
+//#region src/errors.ts
+var SearchIndexStoreError = class extends Data.TaggedError("SearchIndexStoreError") {};
+var KnowledgeExtractionError = class extends Data.TaggedError("KnowledgeExtractionError") {};
+var KnowledgeChunkingError = class extends Data.TaggedError("KnowledgeChunkingError") {};
+var KnowledgeEmbeddingError = class extends Data.TaggedError("KnowledgeEmbeddingError") {};
+var KnowledgeSummarizationError = class extends Data.TaggedError("KnowledgeSummarizationError") {};
+var KnowledgeIngestionError = class extends Data.TaggedError("KnowledgeIngestionError") {};
+var KnowledgeSearchError = class extends Data.TaggedError("KnowledgeSearchError") {};
+var KnowledgeStoreError = class extends Schema$1.TaggedErrorClass()("KnowledgeStoreError", {
+	message: Schema$1.String,
+	cause: Schema$1.optional(Schema$1.Unknown)
+}) {};
+var KnowledgeArtifactError = class extends Schema$1.TaggedErrorClass()("KnowledgeArtifactError", {
+	message: Schema$1.String,
+	cause: Schema$1.optional(Schema$1.Unknown)
+}) {};
+var KnowledgeContextError = class extends Schema$1.TaggedErrorClass()("KnowledgeContextError", {
+	message: Schema$1.String,
+	cause: Schema$1.optional(Schema$1.Unknown)
+}) {};
+//#endregion
+export { KnowledgeArtifactError, KnowledgeChunkingError, KnowledgeContextError, KnowledgeEmbeddingError, KnowledgeExtractionError, KnowledgeIngestionError, KnowledgeSearchError, KnowledgeStoreError, KnowledgeSummarizationError, SearchIndexStoreError };
+
+//# sourceMappingURL=errors.mjs.map

package/dist/errors.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.mjs","names":["Schema"],"sources":["../src/errors.ts"],"sourcesContent":["import { Data } from 'effect'\nimport * as Schema from 'effect/Schema'\n\nexport class SearchIndexStoreError extends Data.TaggedError('SearchIndexStoreError')<{\n  readonly message: string\n  readonly cause?: unknown\n}> {}\n\nexport class KnowledgeExtractionError extends Data.TaggedError('KnowledgeExtractionError')<{\n  readonly message: string\n  readonly cause?: unknown\n}> {}\n\nexport class KnowledgeChunkingError extends Data.TaggedError('KnowledgeChunkingError')<{\n  readonly message: string\n  readonly cause?: unknown\n}> {}\n\nexport class KnowledgeEmbeddingError extends Data.TaggedError('KnowledgeEmbeddingError')<{\n  readonly message: string\n  readonly cause?: unknown\n}> {}\n\nexport class KnowledgeSummarizationError extends Data.TaggedError('KnowledgeSummarizationError')<{\n  readonly message: string\n  readonly cause?: unknown\n}> {}\n\nexport class KnowledgeIngestionError extends Data.TaggedError('KnowledgeIngestionError')<{\n  readonly message: string\n  readonly stage: 'store' | 'extract' | 'chunk' | 'embed' | 'summarize'\n  readonly cause?: unknown\n}> {}\n\nexport class KnowledgeSearchError extends Data.TaggedError('KnowledgeSearchError')<{\n  readonly message: string\n  readonly stage: 'store' | 'embed'\n  readonly cause?: unknown\n}> {}\n\nexport class KnowledgeStoreError extends Schema.TaggedErrorClass<KnowledgeStoreError>()(\n  'KnowledgeStoreError',\n  {\n    message: Schema.String,\n    cause: Schema.optional(Schema.Unknown)\n  }\n) {}\n\nexport class KnowledgeArtifactError extends Schema.TaggedErrorClass<KnowledgeArtifactError>()(\n  'KnowledgeArtifactError',\n  {\n    message: Schema.String,\n    cause: Schema.optional(Schema.Unknown)\n  }\n) {}\n\nexport class KnowledgeContextError extends Schema.TaggedErrorClass<KnowledgeContextError>()(\n  'KnowledgeContextError',\n  {\n    message: Schema.String,\n    cause: Schema.optional(Schema.Unknown)\n  }\n) {}\n"],"mappings":";;;AAGA,IAAa,wBAAb,cAA2C,KAAK,YAAY,uBAAuB,EAGhF,CAAC;AAEJ,IAAa,2BAAb,cAA8C,KAAK,YAAY,0BAA0B,EAGtF,CAAC;AAEJ,IAAa,yBAAb,cAA4C,KAAK,YAAY,wBAAwB,EAGlF,CAAC;AAEJ,IAAa,0BAAb,cAA6C,KAAK,YAAY,yBAAyB,EAGpF,CAAC;AAEJ,IAAa,8BAAb,cAAiD,KAAK,YAAY,6BAA6B,EAG5F,CAAC;AAEJ,IAAa,0BAAb,cAA6C,KAAK,YAAY,yBAAyB,EAIpF,CAAC;AAEJ,IAAa,uBAAb,cAA0C,KAAK,YAAY,sBAAsB,EAI9E,CAAC;AAEJ,IAAa,sBAAb,cAAyCA,SAAO,iBAAsC,EACpF,uBACA;CACE,SAASA,SAAO;CAChB,OAAOA,SAAO,SAASA,SAAO,OAAO;AACvC,CACF,EAAE,CAAC;AAEH,IAAa,yBAAb,cAA4CA,SAAO,iBAAyC,EAC1F,0BACA;CACE,SAASA,SAAO;CAChB,OAAOA,SAAO,SAASA,SAAO,OAAO;AACvC,CACF,EAAE,CAAC;AAEH,IAAa,wBAAb,cAA2CA,SAAO,iBAAwC,EACxF,yBACA;CACE,SAASA,SAAO;CAChB,OAAOA,SAAO,SAASA,SAAO,OAAO;AACvC,CACF,EAAE,CAAC"}

package/dist/extraction.d.mts

@@ -0,0 +1,19 @@
+import { ExtractedKnowledgeDocument, KnowledgeMetadata, KnowledgeSource } from "./documents.mjs";
+import { KnowledgeExtractionError } from "./errors.mjs";
+import { Context, Effect } from "effect";
+
+//#region src/extraction.d.ts
+type LoadedKnowledgeSource = {
+  readonly source: KnowledgeSource;
+  readonly content: string | Uint8Array;
+  readonly mediaType?: string;
+  readonly metadata?: KnowledgeMetadata;
+};
+type KnowledgeExtractorApi = {
+  readonly extract: (source: LoadedKnowledgeSource) => Effect.Effect<ExtractedKnowledgeDocument, KnowledgeExtractionError>;
+};
+declare const KnowledgeExtractor_base: Context.ServiceClass<KnowledgeExtractor, "@yolk-sdk/knowledge/KnowledgeExtractor", KnowledgeExtractorApi>;
+declare class KnowledgeExtractor extends KnowledgeExtractor_base {}
+//#endregion
+export { KnowledgeExtractor, KnowledgeExtractorApi, LoadedKnowledgeSource };
+//# sourceMappingURL=extraction.d.mts.map

package/dist/extraction.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extraction.d.mts","names":[],"sources":["../src/extraction.ts"],"mappings":";;;;;KAKY,qBAAA;EAAA,SACD,MAAA,EAAQ,eAAA;EAAA,SACR,OAAA,WAAkB,UAAA;EAAA,SAClB,SAAA;EAAA,SACA,QAAA,GAAW,iBAAA;AAAA;AAAA,KAGV,qBAAA;EAAA,SACD,OAAA,GACP,MAAA,EAAQ,qBAAA,KACL,MAAA,CAAO,MAAA,CAAO,0BAAA,EAA4B,wBAAA;AAAA;AAAA,cAChD,uBAAA;cAEY,kBAAA,SAA2B,uBAEvC"}

package/dist/extraction.mjs

@@ -0,0 +1,7 @@
+import { Context } from "effect";
+//#region src/extraction.ts
+var KnowledgeExtractor = class extends Context.Service()("@yolk-sdk/knowledge/KnowledgeExtractor") {};
+//#endregion
+export { KnowledgeExtractor };
+
+//# sourceMappingURL=extraction.mjs.map

package/dist/extraction.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"extraction.mjs","names":[],"sources":["../src/extraction.ts"],"sourcesContent":["import { Context } from 'effect'\nimport type { Effect } from 'effect'\nimport type { ExtractedKnowledgeDocument, KnowledgeMetadata, KnowledgeSource } from './documents.ts'\nimport type { KnowledgeExtractionError } from './errors.ts'\n\nexport type LoadedKnowledgeSource = {\n  readonly source: KnowledgeSource\n  readonly content: string | Uint8Array\n  readonly mediaType?: string\n  readonly metadata?: KnowledgeMetadata\n}\n\nexport type KnowledgeExtractorApi = {\n  readonly extract: (\n    source: LoadedKnowledgeSource\n  ) => Effect.Effect<ExtractedKnowledgeDocument, KnowledgeExtractionError>\n}\n\nexport class KnowledgeExtractor extends Context.Service<KnowledgeExtractor, KnowledgeExtractorApi>()(\n  '@yolk-sdk/knowledge/KnowledgeExtractor'\n) {}\n"],"mappings":";;AAkBA,IAAa,qBAAb,cAAwC,QAAQ,QAAmD,EACjG,wCACF,EAAE,CAAC"}

package/dist/index.d.mts

@@ -0,0 +1,5 @@
+import { KnowledgeArtifactError, KnowledgeContextError, KnowledgeStoreError } from "./errors.mjs";
+import { KnowledgeArtifactStore } from "./artifacts.mjs";
+import { buildKnowledgeContext } from "./context.mjs";
+import { KnowledgeStore } from "./store.mjs";
+export { KnowledgeArtifactError, KnowledgeArtifactStore, KnowledgeContextError, KnowledgeStore, KnowledgeStoreError, buildKnowledgeContext };

package/dist/index.mjs

@@ -0,0 +1,5 @@
+import { KnowledgeArtifactError, KnowledgeContextError, KnowledgeStoreError } from "./errors.mjs";
+import { KnowledgeArtifactStore } from "./artifacts.mjs";
+import { buildKnowledgeContext } from "./context.mjs";
+import { KnowledgeStore } from "./store.mjs";
+export { KnowledgeArtifactError, KnowledgeArtifactStore, KnowledgeContextError, KnowledgeStore, KnowledgeStoreError, buildKnowledgeContext };

package/dist/ingestion.d.mts

@@ -0,0 +1,48 @@
+import { KnowledgeIngestionError } from "./errors.mjs";
+import { KnowledgeEmbedder } from "./embeddings.mjs";
+import { SearchIndexStore } from "./search-store.mjs";
+import { KnowledgeChunker } from "./chunking.mjs";
+import { KnowledgeExtractor, LoadedKnowledgeSource } from "./extraction.mjs";
+import { KnowledgeSummarizer } from "./summarization.mjs";
+import { Effect } from "effect";
+
+//#region src/ingestion.d.ts
+type IngestKnowledgeDocumentInput = {
+  readonly collectionId: string;
+  readonly documentId: string;
+  readonly source: LoadedKnowledgeSource;
+  readonly contentHash?: string;
+};
+declare const ingestKnowledgeDocument: (input: IngestKnowledgeDocumentInput) => Effect.Effect<{
+  readonly id: string;
+  readonly collectionId: string;
+  readonly source: {
+    readonly _tag: "File";
+    readonly ref: string;
+    readonly name?: string | undefined;
+    readonly mediaType?: string | undefined;
+  } | {
+    readonly _tag: "Url";
+    readonly url: string;
+  } | {
+    readonly _tag: "Text";
+    readonly label?: string | undefined;
+  };
+  readonly status: "pending" | "processing" | "ready" | "error";
+  readonly metadata?: {
+    readonly [x: string]: unknown;
+  } | undefined;
+  readonly tokenCount?: number | undefined;
+  readonly title?: string | undefined;
+  readonly summary?: string | undefined;
+  readonly errorMessage?: string | undefined;
+  readonly contentHash?: string | undefined;
+  readonly chunkCount?: number | undefined;
+}, KnowledgeIngestionError, SearchIndexStore | KnowledgeEmbedder | KnowledgeSummarizer | KnowledgeChunker | KnowledgeExtractor>;
+type KnowledgeIngestionPipeline = {
+  readonly ingest: (input: IngestKnowledgeDocumentInput) => ReturnType<typeof ingestKnowledgeDocument>;
+};
+declare const makeIngestionPipeline: () => KnowledgeIngestionPipeline;
+//#endregion
+export { IngestKnowledgeDocumentInput, KnowledgeIngestionPipeline, ingestKnowledgeDocument, makeIngestionPipeline };
+//# sourceMappingURL=ingestion.d.mts.map

package/dist/ingestion.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ingestion.d.mts","names":[],"sources":["../src/ingestion.ts"],"mappings":";;;;;;;;;KASY,4BAAA;EAAA,SACD,YAAA;EAAA,SACA,UAAA;EAAA,SACA,MAAA,EAAQ,qBAAqB;EAAA,SAC7B,WAAA;AAAA;AAAA,cAaE,uBAAA,GAA2B,KAAA,EAAO,4BAAA,KAA4B,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;KA4H/D,0BAAA;EAAA,SACD,MAAA,GAAS,KAAA,EAAO,4BAAA,KAAiC,UAAA,QAAkB,uBAAA;AAAA;AAAA,cAGjE,qBAAA,QAA4B,0BAEvC"}

package/dist/ingestion.mjs

@@ -0,0 +1,111 @@
+import { KnowledgeIngestionError } from "./errors.mjs";
+import { KnowledgeEmbedder } from "./embeddings.mjs";
+import { SearchIndexStore } from "./search-store.mjs";
+import { KnowledgeChunker } from "./chunking.mjs";
+import { KnowledgeExtractor } from "./extraction.mjs";
+import { KnowledgeSummarizer } from "./summarization.mjs";
+import { Array, Effect } from "effect";
+//#region src/ingestion.ts
+const markErrorBestEffort = (input, error) => Effect.gen(function* () {
+	yield* (yield* SearchIndexStore).markDocumentError({
+		collectionId: input.collectionId,
+		documentId: input.documentId,
+		message: error.message
+	});
+}).pipe(Effect.catch(() => Effect.void));
+const ingestKnowledgeDocument = (input) => Effect.gen(function* () {
+	yield* Effect.annotateCurrentSpan({
+		"knowledge_search.set_id": input.collectionId,
+		"knowledge_search.document_id": input.documentId,
+		"knowledge_search.source_type": input.source.source._tag
+	});
+	const store = yield* SearchIndexStore;
+	const extractor = yield* KnowledgeExtractor;
+	const chunker = yield* KnowledgeChunker;
+	const embedder = yield* KnowledgeEmbedder;
+	const summarizer = yield* KnowledgeSummarizer;
+	const collection = yield* store.getSet(input.collectionId).pipe(Effect.mapError((error) => new KnowledgeIngestionError({
+		message: error.message,
+		stage: "store",
+		cause: error
+	})));
+	yield* store.upsertDocument({ document: {
+		id: input.documentId,
+		collectionId: input.collectionId,
+		source: input.source.source,
+		status: "processing",
+		metadata: input.source.metadata
+	} }).pipe(Effect.mapError((error) => new KnowledgeIngestionError({
+		message: error.message,
+		stage: "store",
+		cause: error
+	})));
+	const extracted = yield* extractor.extract(input.source).pipe(Effect.mapError((error) => new KnowledgeIngestionError({
+		message: error.message,
+		stage: "extract",
+		cause: error
+	})));
+	const chunks = yield* chunker.chunk({
+		collectionId: input.collectionId,
+		documentId: input.documentId,
+		content: extracted.content,
+		maxTokens: collection.chunkingConfig.maxTokens,
+		metadata: extracted.metadata
+	}).pipe(Effect.mapError((error) => new KnowledgeIngestionError({
+		message: error.message,
+		stage: "chunk",
+		cause: error
+	})));
+	const indexed = yield* Effect.all({
+		embeddings: embedder.embedTexts(chunks.map((chunk) => chunk.content)).pipe(Effect.mapError((error) => new KnowledgeIngestionError({
+			message: error.message,
+			stage: "embed",
+			cause: error
+		}))),
+		summary: summarizer.summarize({
+			content: extracted.content,
+			sourceTitle: extracted.title,
+			metadata: extracted.metadata
+		}).pipe(Effect.mapError((error) => new KnowledgeIngestionError({
+			message: error.message,
+			stage: "summarize",
+			cause: error
+		})))
+	}, { concurrency: "unbounded" });
+	if (indexed.embeddings.length !== chunks.length) return yield* Effect.fail(new KnowledgeIngestionError({
+		message: "Embedding count did not match chunk count",
+		stage: "embed"
+	}));
+	const indexedChunks = Array.zip(chunks, indexed.embeddings).map(([chunk, embedding]) => ({
+		chunk,
+		embedding
+	}));
+	yield* store.replaceDocumentChunks({
+		collectionId: input.collectionId,
+		documentId: input.documentId,
+		chunks: indexedChunks
+	}).pipe(Effect.mapError((error) => new KnowledgeIngestionError({
+		message: error.message,
+		stage: "store",
+		cause: error
+	})));
+	const tokenCount = chunks.reduce((total, chunk) => total + chunk.tokenCount, 0);
+	return yield* store.markDocumentReady({
+		collectionId: input.collectionId,
+		documentId: input.documentId,
+		title: indexed.summary.title ?? extracted.title,
+		summary: indexed.summary.summary ?? extracted.summary,
+		contentHash: input.contentHash,
+		tokenCount,
+		chunkCount: chunks.length
+	}).pipe(Effect.mapError((error) => new KnowledgeIngestionError({
+		message: error.message,
+		stage: "store",
+		cause: error
+	})));
+}).pipe(Effect.withSpan("knowledge_search.ingestDocument"), Effect.catch((error) => markErrorBestEffort(input, error).pipe(Effect.flatMap(() => Effect.fail(error)))));
+const makeIngestionPipeline = () => ({ ingest: ingestKnowledgeDocument });
+//#endregion
+export { ingestKnowledgeDocument, makeIngestionPipeline };
+
+//# sourceMappingURL=ingestion.mjs.map

package/dist/ingestion.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ingestion.mjs","names":["Arr"],"sources":["../src/ingestion.ts"],"sourcesContent":["import { Array as Arr, Effect } from 'effect'\nimport { KnowledgeChunker } from './chunking.ts'\nimport { KnowledgeEmbedder } from './embeddings.ts'\nimport { KnowledgeExtractor } from './extraction.ts'\nimport { KnowledgeSummarizer } from './summarization.ts'\nimport type { LoadedKnowledgeSource } from './extraction.ts'\nimport { KnowledgeIngestionError } from './errors.ts'\nimport { SearchIndexStore } from './search-store.ts'\n\nexport type IngestKnowledgeDocumentInput = {\n  readonly collectionId: string\n  readonly documentId: string\n  readonly source: LoadedKnowledgeSource\n  readonly contentHash?: string\n}\n\nconst markErrorBestEffort = (input: IngestKnowledgeDocumentInput, error: KnowledgeIngestionError) =>\n  Effect.gen(function* () {\n    const store = yield* SearchIndexStore\n    yield* store.markDocumentError({\n      collectionId: input.collectionId,\n      documentId: input.documentId,\n      message: error.message\n    })\n  }).pipe(Effect.catch(() => Effect.void))\n\nexport const ingestKnowledgeDocument = (input: IngestKnowledgeDocumentInput) =>\n  Effect.gen(function* () {\n    yield* Effect.annotateCurrentSpan({\n      'knowledge_search.set_id': input.collectionId,\n      'knowledge_search.document_id': input.documentId,\n      'knowledge_search.source_type': input.source.source._tag\n    })\n    const store = yield* SearchIndexStore\n    const extractor = yield* KnowledgeExtractor\n    const chunker = yield* KnowledgeChunker\n    const embedder = yield* KnowledgeEmbedder\n    const summarizer = yield* KnowledgeSummarizer\n    const collection = yield* store\n      .getSet(input.collectionId)\n      .pipe(\n        Effect.mapError(\n          error => new KnowledgeIngestionError({ message: error.message, stage: 'store', cause: error })\n        )\n      )\n\n    yield* store\n      .upsertDocument({\n        document: {\n          id: input.documentId,\n          collectionId: input.collectionId,\n          source: input.source.source,\n          status: 'processing',\n          metadata: input.source.metadata\n        }\n      })\n      .pipe(\n        Effect.mapError(\n          error => new KnowledgeIngestionError({ message: error.message, stage: 'store', cause: error })\n        )\n      )\n\n    const extracted = yield* extractor\n      .extract(input.source)\n      .pipe(\n        Effect.mapError(\n          error => new KnowledgeIngestionError({ message: error.message, stage: 'extract', cause: error })\n        )\n      )\n\n    const chunks = yield* chunker\n      .chunk({\n        collectionId: input.collectionId,\n        documentId: input.documentId,\n        content: extracted.content,\n        maxTokens: collection.chunkingConfig.maxTokens,\n        metadata: extracted.metadata\n      })\n      .pipe(\n        Effect.mapError(\n          error => new KnowledgeIngestionError({ message: error.message, stage: 'chunk', cause: error })\n        )\n      )\n\n    const indexed = yield* Effect.all(\n      {\n        embeddings: embedder.embedTexts(chunks.map(chunk => chunk.content)).pipe(\n          Effect.mapError(\n            error => new KnowledgeIngestionError({ message: error.message, stage: 'embed', cause: error })\n          )\n        ),\n        summary: summarizer\n          .summarize({\n            content: extracted.content,\n            sourceTitle: extracted.title,\n            metadata: extracted.metadata\n          })\n          .pipe(\n            Effect.mapError(\n              error =>\n                new KnowledgeIngestionError({ message: error.message, stage: 'summarize', cause: error })\n            )\n          )\n      },\n      { concurrency: 'unbounded' }\n    )\n\n    if (indexed.embeddings.length !== chunks.length) {\n      return yield* Effect.fail(\n        new KnowledgeIngestionError({ message: 'Embedding count did not match chunk count', stage: 'embed' })\n      )\n    }\n\n    const indexedChunks = Arr.zip(chunks, indexed.embeddings).map(([chunk, embedding]) => ({\n      chunk,\n      embedding\n    }))\n    yield* store\n      .replaceDocumentChunks({\n        collectionId: input.collectionId,\n        documentId: input.documentId,\n        chunks: indexedChunks\n      })\n      .pipe(\n        Effect.mapError(\n          error => new KnowledgeIngestionError({ message: error.message, stage: 'store', cause: error })\n        )\n      )\n\n    const tokenCount = chunks.reduce((total, chunk) => total + chunk.tokenCount, 0)\n    return yield* store\n      .markDocumentReady({\n        collectionId: input.collectionId,\n        documentId: input.documentId,\n        title: indexed.summary.title ?? extracted.title,\n        summary: indexed.summary.summary ?? extracted.summary,\n        contentHash: input.contentHash,\n        tokenCount,\n        chunkCount: chunks.length\n      })\n      .pipe(\n        Effect.mapError(\n          error => new KnowledgeIngestionError({ message: error.message, stage: 'store', cause: error })\n        )\n      )\n  }).pipe(\n    Effect.withSpan('knowledge_search.ingestDocument'),\n    Effect.catch(error => markErrorBestEffort(input, error).pipe(Effect.flatMap(() => Effect.fail(error))))\n  )\n\nexport type KnowledgeIngestionPipeline = {\n  readonly ingest: (input: IngestKnowledgeDocumentInput) => ReturnType<typeof ingestKnowledgeDocument>\n}\n\nexport const makeIngestionPipeline = (): KnowledgeIngestionPipeline => ({\n  ingest: ingestKnowledgeDocument\n})\n"],"mappings":"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"}

package/dist/links.d.mts

@@ -0,0 +1,17 @@
+import * as Schema from "effect/Schema";
+
+//#region src/links.d.ts
+declare const KnowledgeLinkTypeSchema: Schema.Literals<readonly ["cites", "supports", "contradicts", "supersedes", "mentions", "derived_from", "related_to"]>;
+type KnowledgeLinkType = Schema.Schema.Type<typeof KnowledgeLinkTypeSchema>;
+declare const KnowledgeLinkSchema: Schema.Struct<{
+  readonly id: Schema.Trimmed;
+  readonly fromRecordId: Schema.Trimmed;
+  readonly toRecordId: Schema.Trimmed;
+  readonly type: Schema.Literals<readonly ["cites", "supports", "contradicts", "supersedes", "mentions", "derived_from", "related_to"]>;
+  readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+  readonly createdAt: Schema.DateTimeUtc;
+}>;
+type KnowledgeLink = Schema.Schema.Type<typeof KnowledgeLinkSchema>;
+//#endregion
+export { KnowledgeLink, KnowledgeLinkSchema, KnowledgeLinkType, KnowledgeLinkTypeSchema };
+//# sourceMappingURL=links.d.mts.map

package/dist/links.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"links.d.mts","names":[],"sources":["../src/links.ts"],"mappings":";;;cAGa,uBAAA,EAAuB,MAAA,CAAA,QAAA;AAAA,KASxB,iBAAA,GAAoB,MAAA,CAAO,MAAA,CAAO,IAAI,QAAQ,uBAAA;AAAA,cAE7C,mBAAA,EAAmB,MAAA,CAAA,MAAA;EAAA;;;;;;;KAQpB,aAAA,GAAgB,MAAA,CAAO,MAAA,CAAO,IAAI,QAAQ,mBAAA"}

package/dist/links.mjs

@@ -0,0 +1,24 @@
+import { KnowledgeMetadataSchema, NonEmptyTrimmedString } from "./records.mjs";
+import * as Schema from "effect/Schema";
+//#region src/links.ts
+const KnowledgeLinkTypeSchema = Schema.Literals([
+	"cites",
+	"supports",
+	"contradicts",
+	"supersedes",
+	"mentions",
+	"derived_from",
+	"related_to"
+]);
+const KnowledgeLinkSchema = Schema.Struct({
+	id: NonEmptyTrimmedString,
+	fromRecordId: NonEmptyTrimmedString,
+	toRecordId: NonEmptyTrimmedString,
+	type: KnowledgeLinkTypeSchema,
+	metadata: Schema.optional(KnowledgeMetadataSchema),
+	createdAt: Schema.DateTimeUtc
+});
+//#endregion
+export { KnowledgeLinkSchema, KnowledgeLinkTypeSchema };
+
+//# sourceMappingURL=links.mjs.map

package/dist/links.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"links.mjs","names":[],"sources":["../src/links.ts"],"sourcesContent":["import * as Schema from 'effect/Schema'\nimport { KnowledgeMetadataSchema, NonEmptyTrimmedString } from './records.ts'\n\nexport const KnowledgeLinkTypeSchema = Schema.Literals([\n  'cites',\n  'supports',\n  'contradicts',\n  'supersedes',\n  'mentions',\n  'derived_from',\n  'related_to'\n])\nexport type KnowledgeLinkType = Schema.Schema.Type<typeof KnowledgeLinkTypeSchema>\n\nexport const KnowledgeLinkSchema = Schema.Struct({\n  id: NonEmptyTrimmedString,\n  fromRecordId: NonEmptyTrimmedString,\n  toRecordId: NonEmptyTrimmedString,\n  type: KnowledgeLinkTypeSchema,\n  metadata: Schema.optional(KnowledgeMetadataSchema),\n  createdAt: Schema.DateTimeUtc\n})\nexport type KnowledgeLink = Schema.Schema.Type<typeof KnowledgeLinkSchema>\n"],"mappings":";;;AAGA,MAAa,0BAA0B,OAAO,SAAS;CACrD;CACA;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;AAGD,MAAa,sBAAsB,OAAO,OAAO;CAC/C,IAAI;CACJ,cAAc;CACd,YAAY;CACZ,MAAM;CACN,UAAU,OAAO,SAAS,uBAAuB;CACjD,WAAW,OAAO;AACpB,CAAC"}

package/dist/provenance.d.mts

@@ -0,0 +1,20 @@
+import * as Schema from "effect/Schema";
+
+//#region src/provenance.d.ts
+declare const KnowledgeProvenanceSourceKindSchema: Schema.Literals<readonly ["upload", "user_statement", "url", "generated", "imported", "external_api"]>;
+type KnowledgeProvenanceSourceKind = Schema.Schema.Type<typeof KnowledgeProvenanceSourceKindSchema>;
+declare const KnowledgeProvenanceSchema: Schema.Struct<{
+  readonly id: Schema.Trimmed;
+  readonly recordId: Schema.Trimmed;
+  readonly artifactId: Schema.optional<Schema.Trimmed>;
+  readonly sourceKind: Schema.Literals<readonly ["upload", "user_statement", "url", "generated", "imported", "external_api"]>;
+  readonly sourceLabel: Schema.Trimmed;
+  readonly sourceUrl: Schema.optional<Schema.Trimmed>;
+  readonly observedAt: Schema.optional<Schema.DateTimeUtc>;
+  readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+  readonly createdAt: Schema.DateTimeUtc;
+}>;
+type KnowledgeProvenance = Schema.Schema.Type<typeof KnowledgeProvenanceSchema>;
+//#endregion
+export { KnowledgeProvenance, KnowledgeProvenanceSchema, KnowledgeProvenanceSourceKind, KnowledgeProvenanceSourceKindSchema };
+//# sourceMappingURL=provenance.d.mts.map

package/dist/provenance.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provenance.d.mts","names":[],"sources":["../src/provenance.ts"],"mappings":";;;cAGa,mCAAA,EAAmC,MAAA,CAAA,QAAA;AAAA,KAQpC,6BAAA,GAAgC,MAAA,CAAO,MAAA,CAAO,IAAI,QAAQ,mCAAA;AAAA,cAEzD,yBAAA,EAAyB,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;KAW1B,mBAAA,GAAsB,MAAA,CAAO,MAAA,CAAO,IAAI,QAAQ,yBAAA"}

package/dist/provenance.mjs

@@ -0,0 +1,26 @@
+import { KnowledgeMetadataSchema, NonEmptyTrimmedString } from "./records.mjs";
+import * as Schema from "effect/Schema";
+//#region src/provenance.ts
+const KnowledgeProvenanceSourceKindSchema = Schema.Literals([
+	"upload",
+	"user_statement",
+	"url",
+	"generated",
+	"imported",
+	"external_api"
+]);
+const KnowledgeProvenanceSchema = Schema.Struct({
+	id: NonEmptyTrimmedString,
+	recordId: NonEmptyTrimmedString,
+	artifactId: Schema.optional(NonEmptyTrimmedString),
+	sourceKind: KnowledgeProvenanceSourceKindSchema,
+	sourceLabel: NonEmptyTrimmedString,
+	sourceUrl: Schema.optional(NonEmptyTrimmedString),
+	observedAt: Schema.optional(Schema.DateTimeUtc),
+	metadata: Schema.optional(KnowledgeMetadataSchema),
+	createdAt: Schema.DateTimeUtc
+});
+//#endregion
+export { KnowledgeProvenanceSchema, KnowledgeProvenanceSourceKindSchema };
+
+//# sourceMappingURL=provenance.mjs.map

package/dist/provenance.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"provenance.mjs","names":[],"sources":["../src/provenance.ts"],"sourcesContent":["import * as Schema from 'effect/Schema'\nimport { KnowledgeMetadataSchema, NonEmptyTrimmedString } from './records.ts'\n\nexport const KnowledgeProvenanceSourceKindSchema = Schema.Literals([\n  'upload',\n  'user_statement',\n  'url',\n  'generated',\n  'imported',\n  'external_api'\n])\nexport type KnowledgeProvenanceSourceKind = Schema.Schema.Type<typeof KnowledgeProvenanceSourceKindSchema>\n\nexport const KnowledgeProvenanceSchema = Schema.Struct({\n  id: NonEmptyTrimmedString,\n  recordId: NonEmptyTrimmedString,\n  artifactId: Schema.optional(NonEmptyTrimmedString),\n  sourceKind: KnowledgeProvenanceSourceKindSchema,\n  sourceLabel: NonEmptyTrimmedString,\n  sourceUrl: Schema.optional(NonEmptyTrimmedString),\n  observedAt: Schema.optional(Schema.DateTimeUtc),\n  metadata: Schema.optional(KnowledgeMetadataSchema),\n  createdAt: Schema.DateTimeUtc\n})\nexport type KnowledgeProvenance = Schema.Schema.Type<typeof KnowledgeProvenanceSchema>\n"],"mappings":";;;AAGA,MAAa,sCAAsC,OAAO,SAAS;CACjE;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;AAGD,MAAa,4BAA4B,OAAO,OAAO;CACrD,IAAI;CACJ,UAAU;CACV,YAAY,OAAO,SAAS,qBAAqB;CACjD,YAAY;CACZ,aAAa;CACb,WAAW,OAAO,SAAS,qBAAqB;CAChD,YAAY,OAAO,SAAS,OAAO,WAAW;CAC9C,UAAU,OAAO,SAAS,uBAAuB;CACjD,WAAW,OAAO;AACpB,CAAC"}