@lssm/example.versioned-knowledge-base 0.0.0-canary-20251217063201 → 0.0.0-canary-20251217072406

package/dist/entities/models.d.ts

@@ -1,93 +1,93 @@
-import * as _lssm_lib_schema0 from "@lssm/lib.schema";
+import * as _lssm_lib_schema84 from "@lssm/lib.schema";
 
 //#region src/entities/models.d.ts
-declare const SourceDocumentModel: _lssm_lib_schema0.SchemaModel<{
+declare const SourceDocumentModel: _lssm_lib_schema84.SchemaModel<{
   id: {
-    type: _lssm_lib_schema0.FieldType<string, string>;
+    type: _lssm_lib_schema84.FieldType<string, string>;
     isOptional: false;
   };
   jurisdiction: {
-    type: _lssm_lib_schema0.FieldType<string, string>;
+    type: _lssm_lib_schema84.FieldType<string, string>;
     isOptional: false;
   };
   authority: {
-    type: _lssm_lib_schema0.FieldType<string, string>;
+    type: _lssm_lib_schema84.FieldType<string, string>;
     isOptional: false;
   };
   title: {
-    type: _lssm_lib_schema0.FieldType<string, string>;
+    type: _lssm_lib_schema84.FieldType<string, string>;
     isOptional: false;
   };
   fetchedAt: {
-    type: _lssm_lib_schema0.FieldType<Date, string>;
+    type: _lssm_lib_schema84.FieldType<Date, string>;
     isOptional: false;
   };
   hash: {
-    type: _lssm_lib_schema0.FieldType<string, string>;
+    type: _lssm_lib_schema84.FieldType<string, string>;
     isOptional: false;
   };
   fileId: {
-    type: _lssm_lib_schema0.FieldType<string, string>;
+    type: _lssm_lib_schema84.FieldType<string, string>;
     isOptional: false;
   };
 }>;
-declare const SourceRefModel: _lssm_lib_schema0.SchemaModel<{
+declare const SourceRefModel: _lssm_lib_schema84.SchemaModel<{
   sourceDocumentId: {
-    type: _lssm_lib_schema0.FieldType<string, string>;
+    type: _lssm_lib_schema84.FieldType<string, string>;
     isOptional: false;
   };
   excerpt: {
-    type: _lssm_lib_schema0.FieldType<string, string>;
+    type: _lssm_lib_schema84.FieldType<string, string>;
     isOptional: true;
   };
 }>;
-declare const RuleModel: _lssm_lib_schema0.SchemaModel<{
+declare const RuleModel: _lssm_lib_schema84.SchemaModel<{
   id: {
-    type: _lssm_lib_schema0.FieldType<string, string>;
+    type: _lssm_lib_schema84.FieldType<string, string>;
     isOptional: false;
   };
   jurisdiction: {
-    type: _lssm_lib_schema0.FieldType<string, string>;
+    type: _lssm_lib_schema84.FieldType<string, string>;
     isOptional: false;
   };
   topicKey: {
-    type: _lssm_lib_schema0.FieldType<string, string>;
+    type: _lssm_lib_schema84.FieldType<string, string>;
     isOptional: false;
   };
 }>;
-declare const RuleVersionModel: _lssm_lib_schema0.SchemaModel<{
+declare const RuleVersionModel: _lssm_lib_schema84.SchemaModel<{
   id: {
-    type: _lssm_lib_schema0.FieldType<string, string>;
+    type: _lssm_lib_schema84.FieldType<string, string>;
     isOptional: false;
   };
   ruleId: {
-    type: _lssm_lib_schema0.FieldType<string, string>;
+    type: _lssm_lib_schema84.FieldType<string, string>;
     isOptional: false;
   };
   jurisdiction: {
-    type: _lssm_lib_schema0.FieldType<string, string>;
+    type: _lssm_lib_schema84.FieldType<string, string>;
     isOptional: false;
   };
   topicKey: {
-    type: _lssm_lib_schema0.FieldType<string, string>;
+    type: _lssm_lib_schema84.FieldType<string, string>;
     isOptional: false;
   };
   version: {
-    type: _lssm_lib_schema0.FieldType<number, number>;
+    type: _lssm_lib_schema84.FieldType<number, number>;
     isOptional: false;
   };
   content: {
-    type: _lssm_lib_schema0.FieldType<string, string>;
+    type: _lssm_lib_schema84.FieldType<string, string>;
     isOptional: false;
   };
   sourceRefs: {
-    type: _lssm_lib_schema0.SchemaModel<{
+    type: _lssm_lib_schema84.SchemaModel<{
       sourceDocumentId: {
-        type: _lssm_lib_schema0.FieldType<string, string>;
+        type: _lssm_lib_schema84.FieldType<string, string>;
         isOptional: false;
       };
       excerpt: {
-        type: _lssm_lib_schema0.FieldType<string, string>;
+        type: _lssm_lib_schema84.FieldType<string, string>;
         isOptional: true;
       };
     }>;
@@ -95,42 +95,42 @@ declare const RuleVersionModel: _lssm_lib_schema0.SchemaModel<{
     isOptional: false;
   };
   status: {
-    type: _lssm_lib_schema0.FieldType<string, string>;
+    type: _lssm_lib_schema84.FieldType<string, string>;
     isOptional: false;
   };
   approvedBy: {
-    type: _lssm_lib_schema0.FieldType<string, string>;
+    type: _lssm_lib_schema84.FieldType<string, string>;
     isOptional: true;
   };
   approvedAt: {
-    type: _lssm_lib_schema0.FieldType<Date, string>;
+    type: _lssm_lib_schema84.FieldType<Date, string>;
     isOptional: true;
   };
   createdAt: {
-    type: _lssm_lib_schema0.FieldType<Date, string>;
+    type: _lssm_lib_schema84.FieldType<Date, string>;
     isOptional: false;
   };
 }>;
-declare const KBSnapshotModel: _lssm_lib_schema0.SchemaModel<{
+declare const KBSnapshotModel: _lssm_lib_schema84.SchemaModel<{
   id: {
-    type: _lssm_lib_schema0.FieldType<string, string>;
+    type: _lssm_lib_schema84.FieldType<string, string>;
     isOptional: false;
   };
   jurisdiction: {
-    type: _lssm_lib_schema0.FieldType<string, string>;
+    type: _lssm_lib_schema84.FieldType<string, string>;
     isOptional: false;
   };
   asOfDate: {
-    type: _lssm_lib_schema0.FieldType<Date, string>;
+    type: _lssm_lib_schema84.FieldType<Date, string>;
     isOptional: false;
   };
   includedRuleVersionIds: {
-    type: _lssm_lib_schema0.FieldType<string, string>;
+    type: _lssm_lib_schema84.FieldType<string, string>;
     isArray: true;
     isOptional: false;
   };
   publishedAt: {
-    type: _lssm_lib_schema0.FieldType<Date, string>;
+    type: _lssm_lib_schema84.FieldType<Date, string>;
     isOptional: false;
   };
 }>;

package/dist/entities/models.js

@@ -1 +1,152 @@
-import{l as e}from"../libs/schema/dist/ScalarTypeEnum.js";import{n as t}from"../libs/schema/dist/SchemaModel.js";import"../libs/schema/dist/index.js";const n=t({name:`SourceDocument`,description:`Immutable raw source document metadata referencing a stored file.`,fields:{id:{type:e.String_unsecure(),isOptional:!1},jurisdiction:{type:e.String_unsecure(),isOptional:!1},authority:{type:e.String_unsecure(),isOptional:!1},title:{type:e.String_unsecure(),isOptional:!1},fetchedAt:{type:e.DateTime(),isOptional:!1},hash:{type:e.String_unsecure(),isOptional:!1},fileId:{type:e.String_unsecure(),isOptional:!1}}}),r=t({name:`SourceRef`,description:`Reference to a source document used to justify a rule version.`,fields:{sourceDocumentId:{type:e.String_unsecure(),isOptional:!1},excerpt:{type:e.String_unsecure(),isOptional:!0}}}),i=t({name:`Rule`,description:`Curated rule (stable identity) with topic + jurisdiction scope.`,fields:{id:{type:e.String_unsecure(),isOptional:!1},jurisdiction:{type:e.String_unsecure(),isOptional:!1},topicKey:{type:e.String_unsecure(),isOptional:!1}}}),a=t({name:`RuleVersion`,description:`A versioned rule content with source references and approval status.`,fields:{id:{type:e.String_unsecure(),isOptional:!1},ruleId:{type:e.String_unsecure(),isOptional:!1},jurisdiction:{type:e.String_unsecure(),isOptional:!1},topicKey:{type:e.String_unsecure(),isOptional:!1},version:{type:e.Int_unsecure(),isOptional:!1},content:{type:e.String_unsecure(),isOptional:!1},sourceRefs:{type:r,isArray:!0,isOptional:!1},status:{type:e.String_unsecure(),isOptional:!1},approvedBy:{type:e.String_unsecure(),isOptional:!0},approvedAt:{type:e.DateTime(),isOptional:!0},createdAt:{type:e.DateTime(),isOptional:!1}}}),o=t({name:`KBSnapshot`,description:`Published KB snapshot (as-of) referencing approved rule versions.`,fields:{id:{type:e.String_unsecure(),isOptional:!1},jurisdiction:{type:e.String_unsecure(),isOptional:!1},asOfDate:{type:e.DateTime(),isOptional:!1},includedRuleVersionIds:{type:e.String_unsecure(),isArray:!0,isOptional:!1},publishedAt:{type:e.DateTime(),isOptional:!1}}});export{o as KBSnapshotModel,i as RuleModel,a as RuleVersionModel,n as SourceDocumentModel,r as SourceRefModel};
+import { ScalarTypeEnum } from "../libs/schema/dist/ScalarTypeEnum.js";
+import { defineSchemaModel } from "../libs/schema/dist/SchemaModel.js";
+import "../libs/schema/dist/index.js";
+
+//#region src/entities/models.ts
+const SourceDocumentModel = defineSchemaModel({
+	name: "SourceDocument",
+	description: "Immutable raw source document metadata referencing a stored file.",
+	fields: {
+		id: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false
+		},
+		jurisdiction: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false
+		},
+		authority: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false
+		},
+		title: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false
+		},
+		fetchedAt: {
+			type: ScalarTypeEnum.DateTime(),
+			isOptional: false
+		},
+		hash: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false
+		},
+		fileId: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false
+		}
+	}
+});
+const SourceRefModel = defineSchemaModel({
+	name: "SourceRef",
+	description: "Reference to a source document used to justify a rule version.",
+	fields: {
+		sourceDocumentId: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false
+		},
+		excerpt: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: true
+		}
+	}
+});
+const RuleModel = defineSchemaModel({
+	name: "Rule",
+	description: "Curated rule (stable identity) with topic + jurisdiction scope.",
+	fields: {
+		id: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false
+		},
+		jurisdiction: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false
+		},
+		topicKey: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false
+		}
+	}
+});
+const RuleVersionModel = defineSchemaModel({
+	name: "RuleVersion",
+	description: "A versioned rule content with source references and approval status.",
+	fields: {
+		id: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false
+		},
+		ruleId: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false
+		},
+		jurisdiction: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false
+		},
+		topicKey: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false
+		},
+		version: {
+			type: ScalarTypeEnum.Int_unsecure(),
+			isOptional: false
+		},
+		content: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false
+		},
+		sourceRefs: {
+			type: SourceRefModel,
+			isArray: true,
+			isOptional: false
+		},
+		status: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false
+		},
+		approvedBy: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: true
+		},
+		approvedAt: {
+			type: ScalarTypeEnum.DateTime(),
+			isOptional: true
+		},
+		createdAt: {
+			type: ScalarTypeEnum.DateTime(),
+			isOptional: false
+		}
+	}
+});
+const KBSnapshotModel = defineSchemaModel({
+	name: "KBSnapshot",
+	description: "Published KB snapshot (as-of) referencing approved rule versions.",
+	fields: {
+		id: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false
+		},
+		jurisdiction: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false
+		},
+		asOfDate: {
+			type: ScalarTypeEnum.DateTime(),
+			isOptional: false
+		},
+		includedRuleVersionIds: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isArray: true,
+			isOptional: false
+		},
+		publishedAt: {
+			type: ScalarTypeEnum.DateTime(),
+			isOptional: false
+		}
+	}
+});
+
+//#endregion
+export { KBSnapshotModel, RuleModel, RuleVersionModel, SourceDocumentModel, SourceRefModel };

package/dist/events.d.ts

@@ -1,60 +1,60 @@
-import * as _lssm_lib_schema34 from "@lssm/lib.schema";
+import * as _lssm_lib_schema0 from "@lssm/lib.schema";
 import * as _lssm_lib_contracts0 from "@lssm/lib.contracts";
 
 //#region src/events.d.ts
-declare const KbSourceIngestedEvent: _lssm_lib_contracts0.EventSpec<_lssm_lib_schema34.SchemaModel<{
+declare const KbSourceIngestedEvent: _lssm_lib_contracts0.EventSpec<_lssm_lib_schema0.SchemaModel<{
   sourceDocumentId: {
-    type: _lssm_lib_schema34.FieldType<string, string>;
+    type: _lssm_lib_schema0.FieldType<string, string>;
     isOptional: false;
   };
   jurisdiction: {
-    type: _lssm_lib_schema34.FieldType<string, string>;
+    type: _lssm_lib_schema0.FieldType<string, string>;
     isOptional: false;
   };
   hash: {
-    type: _lssm_lib_schema34.FieldType<string, string>;
+    type: _lssm_lib_schema0.FieldType<string, string>;
     isOptional: false;
   };
 }>>;
-declare const KbRuleVersionCreatedEvent: _lssm_lib_contracts0.EventSpec<_lssm_lib_schema34.SchemaModel<{
+declare const KbRuleVersionCreatedEvent: _lssm_lib_contracts0.EventSpec<_lssm_lib_schema0.SchemaModel<{
   ruleVersionId: {
-    type: _lssm_lib_schema34.FieldType<string, string>;
+    type: _lssm_lib_schema0.FieldType<string, string>;
     isOptional: false;
   };
   ruleId: {
-    type: _lssm_lib_schema34.FieldType<string, string>;
+    type: _lssm_lib_schema0.FieldType<string, string>;
     isOptional: false;
   };
   jurisdiction: {
-    type: _lssm_lib_schema34.FieldType<string, string>;
+    type: _lssm_lib_schema0.FieldType<string, string>;
     isOptional: false;
   };
   status: {
-    type: _lssm_lib_schema34.FieldType<string, string>;
+    type: _lssm_lib_schema0.FieldType<string, string>;
     isOptional: false;
   };
 }>>;
-declare const KbRuleVersionApprovedEvent: _lssm_lib_contracts0.EventSpec<_lssm_lib_schema34.SchemaModel<{
+declare const KbRuleVersionApprovedEvent: _lssm_lib_contracts0.EventSpec<_lssm_lib_schema0.SchemaModel<{
   ruleVersionId: {
-    type: _lssm_lib_schema34.FieldType<string, string>;
+    type: _lssm_lib_schema0.FieldType<string, string>;
     isOptional: false;
   };
   approver: {
-    type: _lssm_lib_schema34.FieldType<string, string>;
+    type: _lssm_lib_schema0.FieldType<string, string>;
     isOptional: false;
   };
 }>>;
-declare const KbSnapshotPublishedEvent: _lssm_lib_contracts0.EventSpec<_lssm_lib_schema34.SchemaModel<{
+declare const KbSnapshotPublishedEvent: _lssm_lib_contracts0.EventSpec<_lssm_lib_schema0.SchemaModel<{
   snapshotId: {
-    type: _lssm_lib_schema34.FieldType<string, string>;
+    type: _lssm_lib_schema0.FieldType<string, string>;
     isOptional: false;
   };
   jurisdiction: {
-    type: _lssm_lib_schema34.FieldType<string, string>;
+    type: _lssm_lib_schema0.FieldType<string, string>;
     isOptional: false;
   };
   includedRuleVersionsCount: {
-    type: _lssm_lib_schema34.FieldType<number, number>;
+    type: _lssm_lib_schema0.FieldType<number, number>;
     isOptional: false;
   };
 }>>;

package/dist/events.js

@@ -1 +1,106 @@
-import{n as e}from"./libs/contracts/dist/schema/dist/SchemaModel.js";import{e as t}from"./libs/contracts/dist/events.js";import"./libs/contracts/dist/index.js";import{l as n}from"./libs/schema/dist/ScalarTypeEnum.js";import"./libs/schema/dist/index.js";const r=t({name:`kb.source.ingested`,version:1,description:`Source document ingested (immutable).`,payload:e({name:`KbSourceIngestedPayload`,description:`Emitted when a source document is ingested.`,fields:{sourceDocumentId:{type:n.String_unsecure(),isOptional:!1},jurisdiction:{type:n.String_unsecure(),isOptional:!1},hash:{type:n.String_unsecure(),isOptional:!1}}})}),i=t({name:`kb.ruleVersion.created`,version:1,description:`Rule version created (draft).`,payload:e({name:`KbRuleVersionCreatedPayload`,description:`Emitted when a rule version draft is created.`,fields:{ruleVersionId:{type:n.String_unsecure(),isOptional:!1},ruleId:{type:n.String_unsecure(),isOptional:!1},jurisdiction:{type:n.String_unsecure(),isOptional:!1},status:{type:n.String_unsecure(),isOptional:!1}}})}),a=t({name:`kb.ruleVersion.approved`,version:1,description:`Rule version approved (human verified).`,payload:e({name:`KbRuleVersionApprovedPayload`,description:`Emitted when a rule version is approved.`,fields:{ruleVersionId:{type:n.String_unsecure(),isOptional:!1},approver:{type:n.String_unsecure(),isOptional:!1}}})}),o=t({name:`kb.snapshot.published`,version:1,description:`KB snapshot published.`,payload:e({name:`KbSnapshotPublishedPayload`,description:`Emitted when a KB snapshot is published.`,fields:{snapshotId:{type:n.String_unsecure(),isOptional:!1},jurisdiction:{type:n.String_unsecure(),isOptional:!1},includedRuleVersionsCount:{type:n.Int_unsecure(),isOptional:!1}}})});export{a as KbRuleVersionApprovedEvent,i as KbRuleVersionCreatedEvent,o as KbSnapshotPublishedEvent,r as KbSourceIngestedEvent};
+import { defineSchemaModel } from "./libs/contracts/dist/schema/dist/SchemaModel.js";
+import { defineEvent } from "./libs/contracts/dist/events.js";
+import "./libs/contracts/dist/index.js";
+import { ScalarTypeEnum } from "./libs/schema/dist/ScalarTypeEnum.js";
+import "./libs/schema/dist/index.js";
+
+//#region src/events.ts
+const KbSourceIngestedPayload = defineSchemaModel({
+	name: "KbSourceIngestedPayload",
+	description: "Emitted when a source document is ingested.",
+	fields: {
+		sourceDocumentId: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false
+		},
+		jurisdiction: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false
+		},
+		hash: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false
+		}
+	}
+});
+const KbSourceIngestedEvent = defineEvent({
+	name: "kb.source.ingested",
+	version: 1,
+	description: "Source document ingested (immutable).",
+	payload: KbSourceIngestedPayload
+});
+const KbRuleVersionCreatedPayload = defineSchemaModel({
+	name: "KbRuleVersionCreatedPayload",
+	description: "Emitted when a rule version draft is created.",
+	fields: {
+		ruleVersionId: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false
+		},
+		ruleId: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false
+		},
+		jurisdiction: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false
+		},
+		status: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false
+		}
+	}
+});
+const KbRuleVersionCreatedEvent = defineEvent({
+	name: "kb.ruleVersion.created",
+	version: 1,
+	description: "Rule version created (draft).",
+	payload: KbRuleVersionCreatedPayload
+});
+const KbRuleVersionApprovedPayload = defineSchemaModel({
+	name: "KbRuleVersionApprovedPayload",
+	description: "Emitted when a rule version is approved.",
+	fields: {
+		ruleVersionId: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false
+		},
+		approver: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false
+		}
+	}
+});
+const KbRuleVersionApprovedEvent = defineEvent({
+	name: "kb.ruleVersion.approved",
+	version: 1,
+	description: "Rule version approved (human verified).",
+	payload: KbRuleVersionApprovedPayload
+});
+const KbSnapshotPublishedPayload = defineSchemaModel({
+	name: "KbSnapshotPublishedPayload",
+	description: "Emitted when a KB snapshot is published.",
+	fields: {
+		snapshotId: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false
+		},
+		jurisdiction: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false
+		},
+		includedRuleVersionsCount: {
+			type: ScalarTypeEnum.Int_unsecure(),
+			isOptional: false
+		}
+	}
+});
+const KbSnapshotPublishedEvent = defineEvent({
+	name: "kb.snapshot.published",
+	version: 1,
+	description: "KB snapshot published.",
+	payload: KbSnapshotPublishedPayload
+});
+
+//#endregion
+export { KbRuleVersionApprovedEvent, KbRuleVersionCreatedEvent, KbSnapshotPublishedEvent, KbSourceIngestedEvent };

package/dist/example.js

@@ -1 +1,41 @@
-var e={id:`versioned-knowledge-base`,title:`Versioned Knowledge Base`,summary:`Curated KB with immutable sources, reviewable rule versions, and published snapshots.`,tags:[`knowledge`,`versioning`,`snapshots`],kind:`knowledge`,visibility:`public`,docs:{rootDocId:`docs.examples.versioned-knowledge-base`},entrypoints:{packageName:`@lssm/example.versioned-knowledge-base`,feature:`./feature`,contracts:`./contracts`,handlers:`./handlers`,docs:`./docs`},surfaces:{templates:!0,sandbox:{enabled:!0,modes:[`markdown`,`specs`,`builder`]},studio:{enabled:!0,installable:!0},mcp:{enabled:!0}}};export{e as default};
+//#region src/example.ts
+const example = {
+	id: "versioned-knowledge-base",
+	title: "Versioned Knowledge Base",
+	summary: "Curated KB with immutable sources, reviewable rule versions, and published snapshots.",
+	tags: [
+		"knowledge",
+		"versioning",
+		"snapshots"
+	],
+	kind: "knowledge",
+	visibility: "public",
+	docs: { rootDocId: "docs.examples.versioned-knowledge-base" },
+	entrypoints: {
+		packageName: "@lssm/example.versioned-knowledge-base",
+		feature: "./feature",
+		contracts: "./contracts",
+		handlers: "./handlers",
+		docs: "./docs"
+	},
+	surfaces: {
+		templates: true,
+		sandbox: {
+			enabled: true,
+			modes: [
+				"markdown",
+				"specs",
+				"builder"
+			]
+		},
+		studio: {
+			enabled: true,
+			installable: true
+		},
+		mcp: { enabled: true }
+	}
+};
+var example_default = example;
+
+//#endregion
+export { example_default as default };

package/dist/handlers/index.js

@@ -1 +1,3 @@
-import{createMemoryKbHandlers as e,createMemoryKbStore as t}from"./memory.handlers.js";export{e as createMemoryKbHandlers,t as createMemoryKbStore};
+import { createMemoryKbHandlers, createMemoryKbStore } from "./memory.handlers.js";
+
+export { createMemoryKbHandlers, createMemoryKbStore };

package/dist/handlers/memory.handlers.js

@@ -1 +1,103 @@
-function e(){return{sources:new Map,rules:new Map,ruleVersions:new Map,snapshots:new Map,nextRuleVersionNumberByRuleId:new Map}}function t(e,t){return`${e}_${t.replace(/[^a-zA-Z0-9_-]/g,`_`)}`}function n(e){async function n(t){return e.rules.set(t.id,t),t}async function r(n){let r=t(`src`,`${n.jurisdiction}_${n.hash}`),i={id:r,...n};return e.sources.set(r,i),i}async function i(n){if(!n.sourceRefs.length)throw Error(`SOURCE_REFS_REQUIRED`);let r=e.rules.get(n.ruleId);if(!r)throw Error(`RULE_NOT_FOUND`);let i=(e.nextRuleVersionNumberByRuleId.get(n.ruleId)??0)+1;e.nextRuleVersionNumberByRuleId.set(n.ruleId,i);let a=t(`rv`,`${n.ruleId}_${i}`),o={id:a,ruleId:n.ruleId,jurisdiction:r.jurisdiction,topicKey:r.topicKey,version:i,content:n.content,sourceRefs:n.sourceRefs,status:`draft`,createdAt:new Date,approvedAt:void 0,approvedBy:void 0};return e.ruleVersions.set(a,o),o}async function a(t){let n=e.ruleVersions.get(t.ruleVersionId);if(!n)throw Error(`RULE_VERSION_NOT_FOUND`);let r={...n,status:`approved`,approvedBy:t.approver,approvedAt:new Date};return e.ruleVersions.set(r.id,r),r}async function o(n){let r=[...e.ruleVersions.values()].filter(e=>e.status===`approved`&&e.jurisdiction===n.jurisdiction);if(r.length===0)throw Error(`NO_APPROVED_RULES`);let i=r.map(e=>e.id).sort(),a=t(`snap`,`${n.jurisdiction}_${n.asOfDate.toISOString().slice(0,10)}_${i.length}`),o={id:a,jurisdiction:n.jurisdiction,asOfDate:n.asOfDate,includedRuleVersionIds:i,publishedAt:new Date};return e.snapshots.set(a,o),o}async function s(t){let n=e.snapshots.get(t.snapshotId);if(!n)throw Error(`SNAPSHOT_NOT_FOUND`);if(n.jurisdiction!==t.jurisdiction)throw Error(`JURISDICTION_MISMATCH`);let r=t.query.toLowerCase().split(/\s+/).map(e=>e.trim()).filter(Boolean);return{items:n.includedRuleVersionIds.map(t=>e.ruleVersions.get(t)).filter(e=>!!e).filter(e=>{if(r.length===0)return!0;let t=e.content.toLowerCase();return r.every(e=>t.includes(e))}).map(e=>({ruleVersionId:e.id,excerpt:e.content.slice(0,120)}))}}return{createRule:n,ingestSource:r,upsertRuleVersion:i,approveRuleVersion:a,publishSnapshot:o,search:s}}export{n as createMemoryKbHandlers,e as createMemoryKbStore};
+//#region src/handlers/memory.handlers.ts
+function createMemoryKbStore() {
+	return {
+		sources: /* @__PURE__ */ new Map(),
+		rules: /* @__PURE__ */ new Map(),
+		ruleVersions: /* @__PURE__ */ new Map(),
+		snapshots: /* @__PURE__ */ new Map(),
+		nextRuleVersionNumberByRuleId: /* @__PURE__ */ new Map()
+	};
+}
+function stableId(prefix, value) {
+	return `${prefix}_${value.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+}
+function createMemoryKbHandlers(store) {
+	async function createRule(rule) {
+		store.rules.set(rule.id, rule);
+		return rule;
+	}
+	async function ingestSource(input) {
+		const id = stableId("src", `${input.jurisdiction}_${input.hash}`);
+		const doc = {
+			id,
+			...input
+		};
+		store.sources.set(id, doc);
+		return doc;
+	}
+	async function upsertRuleVersion(input) {
+		if (!input.sourceRefs.length) throw new Error("SOURCE_REFS_REQUIRED");
+		const rule = store.rules.get(input.ruleId);
+		if (!rule) throw new Error("RULE_NOT_FOUND");
+		const next = (store.nextRuleVersionNumberByRuleId.get(input.ruleId) ?? 0) + 1;
+		store.nextRuleVersionNumberByRuleId.set(input.ruleId, next);
+		const id = stableId("rv", `${input.ruleId}_${next}`);
+		const ruleVersion = {
+			id,
+			ruleId: input.ruleId,
+			jurisdiction: rule.jurisdiction,
+			topicKey: rule.topicKey,
+			version: next,
+			content: input.content,
+			sourceRefs: input.sourceRefs,
+			status: "draft",
+			createdAt: /* @__PURE__ */ new Date(),
+			approvedAt: void 0,
+			approvedBy: void 0
+		};
+		store.ruleVersions.set(id, ruleVersion);
+		return ruleVersion;
+	}
+	async function approveRuleVersion(input) {
+		const existing = store.ruleVersions.get(input.ruleVersionId);
+		if (!existing) throw new Error("RULE_VERSION_NOT_FOUND");
+		const approved = {
+			...existing,
+			status: "approved",
+			approvedBy: input.approver,
+			approvedAt: /* @__PURE__ */ new Date()
+		};
+		store.ruleVersions.set(approved.id, approved);
+		return approved;
+	}
+	async function publishSnapshot(input) {
+		const approved = [...store.ruleVersions.values()].filter((rv) => rv.status === "approved" && rv.jurisdiction === input.jurisdiction);
+		if (approved.length === 0) throw new Error("NO_APPROVED_RULES");
+		const includedRuleVersionIds = approved.map((rv) => rv.id).sort();
+		const id = stableId("snap", `${input.jurisdiction}_${input.asOfDate.toISOString().slice(0, 10)}_${includedRuleVersionIds.length}`);
+		const snapshot = {
+			id,
+			jurisdiction: input.jurisdiction,
+			asOfDate: input.asOfDate,
+			includedRuleVersionIds,
+			publishedAt: /* @__PURE__ */ new Date()
+		};
+		store.snapshots.set(id, snapshot);
+		return snapshot;
+	}
+	async function search(input) {
+		const snapshot = store.snapshots.get(input.snapshotId);
+		if (!snapshot) throw new Error("SNAPSHOT_NOT_FOUND");
+		if (snapshot.jurisdiction !== input.jurisdiction) throw new Error("JURISDICTION_MISMATCH");
+		const tokens = input.query.toLowerCase().split(/\s+/).map((t) => t.trim()).filter(Boolean);
+		return { items: snapshot.includedRuleVersionIds.map((id) => store.ruleVersions.get(id)).filter((rv) => Boolean(rv)).filter((rv) => {
+			if (tokens.length === 0) return true;
+			const hay = rv.content.toLowerCase();
+			return tokens.every((token) => hay.includes(token));
+		}).map((rv) => ({
+			ruleVersionId: rv.id,
+			excerpt: rv.content.slice(0, 120)
+		})) };
+	}
+	return {
+		createRule,
+		ingestSource,
+		upsertRuleVersion,
+		approveRuleVersion,
+		publishSnapshot,
+		search
+	};
+}
+
+//#endregion
+export { createMemoryKbHandlers, createMemoryKbStore };