@contractspec/example.versioned-knowledge-base 0.0.0-canary-20260113162409

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@contractspec/example.versioned-knowledge-base",
+  "version": "0.0.0-canary-20260113162409",
+  "description": "Example: curated, versioned knowledge base with immutable sources, rule versions, and published snapshots.",
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./docs": "./dist/docs/index.js",
+    "./docs/versioned-knowledge-base.docblock": "./dist/docs/versioned-knowledge-base.docblock.js",
+    "./entities": "./dist/entities/index.js",
+    "./entities/models": "./dist/entities/models.js",
+    "./events": "./dist/events.js",
+    "./example": "./dist/example.js",
+    "./handlers": "./dist/handlers/index.js",
+    "./handlers/memory.handlers": "./dist/handlers/memory.handlers.js",
+    "./operations": "./dist/operations/index.js",
+    "./operations/kb": "./dist/operations/kb.js",
+    "./versioned-knowledge-base.feature": "./dist/versioned-knowledge-base.feature.js",
+    "./*": "./*"
+  },
+  "scripts": {
+    "publish:pkg": "bun publish --tolerate-republish --ignore-scripts --verbose",
+    "publish:pkg:canary": "bun publish:pkg --tag canary",
+    "build": "bun build:types && bun build:bundle",
+    "build:bundle": "tsdown",
+    "build:types": "tsc --noEmit",
+    "dev": "bun build:bundle --watch",
+    "clean": "rimraf dist .turbo",
+    "lint": "bun lint:fix",
+    "lint:fix": "eslint src --fix",
+    "lint:check": "eslint src",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "@contractspec/lib.contracts": "0.0.0-canary-20260113162409",
+    "@contractspec/lib.schema": "0.0.0-canary-20260113162409"
+  },
+  "devDependencies": {
+    "@contractspec/tool.tsdown": "0.0.0-canary-20260113162409",
+    "@contractspec/tool.typescript": "0.0.0-canary-20260113162409",
+    "tsdown": "^0.19.0",
+    "typescript": "^5.9.3"
+  },
+  "publishConfig": {
+    "access": "public",
+    "exports": {
+      ".": "./dist/index.js",
+      "./contracts": "./dist/contracts/index.js",
+      "./contracts/kb": "./dist/contracts/kb.js",
+      "./docs": "./dist/docs/index.js",
+      "./docs/versioned-knowledge-base.docblock": "./dist/docs/versioned-knowledge-base.docblock.js",
+      "./entities": "./dist/entities/index.js",
+      "./entities/models": "./dist/entities/models.js",
+      "./events": "./dist/events.js",
+      "./example": "./dist/example.js",
+      "./handlers": "./dist/handlers/index.js",
+      "./handlers/memory.handlers": "./dist/handlers/memory.handlers.js",
+      "./versioned-knowledge-base.feature": "./dist/versioned-knowledge-base.feature.js",
+      "./*": "./*"
+    },
+    "registry": "https://registry.npmjs.org/"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lssm-tech/contractspec.git",
+    "directory": "packages/examples/versioned-knowledge-base"
+  },
+  "homepage": "https://contractspec.io"
+}

package/src/docs/index.ts

@@ -0,0 +1 @@
+import './versioned-knowledge-base.docblock';

package/src/docs/versioned-knowledge-base.docblock.ts

@@ -0,0 +1,29 @@
+import type { DocBlock } from '@contractspec/lib.contracts/docs';
+import { registerDocBlocks } from '@contractspec/lib.contracts/docs';
+
+const docBlocks: DocBlock[] = [
+  {
+    id: 'docs.examples.versioned-knowledge-base.goal',
+    title: 'Versioned Knowledge Base — Goal',
+    summary:
+      'Curated KB with immutable sources, versioned rules, and published snapshots referenced by answers.',
+    kind: 'goal',
+    visibility: 'public',
+    route: '/docs/examples/versioned-knowledge-base/goal',
+    tags: ['knowledge', 'versioning', 'snapshots', 'traceability'],
+    body: `## Why it matters
+- Separates raw sources from curated knowledge.\n- Ensures assistant answers cite a published snapshot.\n- Makes change review and safe regeneration possible.\n\n## Core invariants\n- Sources are immutable and content-addressed (hash).\n- Rule versions must cite at least one source.\n- Snapshots include only approved rule versions.`,
+  },
+  {
+    id: 'docs.examples.versioned-knowledge-base.reference',
+    title: 'Versioned Knowledge Base — Reference',
+    summary: 'Entities, contracts, and events for the versioned KB example.',
+    kind: 'reference',
+    visibility: 'public',
+    route: '/docs/examples/versioned-knowledge-base',
+    tags: ['knowledge', 'reference'],
+    body: `## Contracts\n- kb.ingestSource\n- kb.upsertRuleVersion\n- kb.approveRuleVersion\n- kb.publishSnapshot\n- kb.search\n\n## Events\n- kb.source.ingested\n- kb.ruleVersion.created\n- kb.ruleVersion.approved\n- kb.snapshot.published`,
+  },
+];
+
+registerDocBlocks(docBlocks);

package/src/entities/index.ts

@@ -0,0 +1 @@
+export * from './models';

package/src/entities/models.ts

@@ -0,0 +1,75 @@
+import { ScalarTypeEnum, defineSchemaModel } from '@contractspec/lib.schema';
+
+export 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 },
+  },
+});
+
+export 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 },
+  },
+});
+
+export 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 },
+  },
+});
+
+export 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.String_unsecure(), isOptional: false },
+    content: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    sourceRefs: { type: SourceRefModel, isArray: true, isOptional: false },
+    status: { type: ScalarTypeEnum.String_unsecure(), isOptional: false }, // draft|approved|rejected
+    approvedBy: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    approvedAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+  },
+});
+
+export 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 },
+  },
+});

package/src/events.ts

@@ -0,0 +1,102 @@
+import { defineEvent, defineSchemaModel } from '@contractspec/lib.contracts';
+import { ScalarTypeEnum } from '@contractspec/lib.schema';
+
+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 },
+  },
+});
+
+export const KbSourceIngestedEvent = defineEvent({
+  meta: {
+    key: 'kb.source.ingested',
+    version: '1.0.0',
+    description: 'Source document ingested (immutable).',
+    stability: 'experimental',
+    owners: ['@examples'],
+    tags: ['knowledge'],
+  },
+  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 },
+  },
+});
+
+export const KbRuleVersionCreatedEvent = defineEvent({
+  meta: {
+    key: 'kb.ruleVersion.created',
+    version: '1.0.0',
+    description: 'Rule version created (draft).',
+    stability: 'experimental',
+    owners: ['@examples'],
+    tags: ['knowledge'],
+  },
+  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 },
+  },
+});
+
+export const KbRuleVersionApprovedEvent = defineEvent({
+  meta: {
+    key: 'kb.ruleVersion.approved',
+    version: '1.0.0',
+    description: 'Rule version approved (human verified).',
+    stability: 'experimental',
+    owners: ['@examples'],
+    tags: ['knowledge'],
+  },
+  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,
+    },
+  },
+});
+
+export const KbSnapshotPublishedEvent = defineEvent({
+  meta: {
+    key: 'kb.snapshot.published',
+    version: '1.0.0',
+    description: 'KB snapshot published.',
+    stability: 'experimental',
+    owners: ['@examples'],
+    tags: ['knowledge'],
+  },
+  payload: KbSnapshotPublishedPayload,
+});

package/src/example.ts

@@ -0,0 +1,34 @@
+import { defineExample } from '@contractspec/lib.contracts';
+
+const example = defineExample({
+  meta: {
+    key: 'versioned-knowledge-base',
+    version: '1.0.0',
+    title: 'Versioned Knowledge Base',
+    description:
+      'Curated KB with immutable sources, reviewable rule versions, and published snapshots.',
+    kind: 'knowledge',
+    visibility: 'public',
+    stability: 'experimental',
+    owners: ['@platform.core'],
+    tags: ['knowledge', 'versioning', 'snapshots'],
+  },
+  docs: {
+    rootDocId: 'docs.examples.versioned-knowledge-base',
+  },
+  entrypoints: {
+    packageName: '@contractspec/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 },
+  },
+});
+
+export default example;

package/src/handlers/index.ts

@@ -0,0 +1 @@
+export * from './memory.handlers';

package/src/handlers/memory.handlers.test.ts

@@ -0,0 +1,81 @@
+import { describe, expect, it } from 'bun:test';
+
+import { createMemoryKbHandlers, createMemoryKbStore } from './memory.handlers';
+
+describe('@contractspec/example.versioned-knowledge-base memory handlers', () => {
+  it('requires sourceRefs for rule versions (traceability)', async () => {
+    const store = createMemoryKbStore();
+    const kb = createMemoryKbHandlers(store);
+    await kb.createRule({ id: 'rule_1', jurisdiction: 'EU', topicKey: 't1' });
+    await expect(
+      kb.upsertRuleVersion({ ruleId: 'rule_1', content: 'x', sourceRefs: [] })
+    ).rejects.toThrow('SOURCE_REFS_REQUIRED');
+  });
+
+  it('snapshot includes only approved rule versions for that jurisdiction', async () => {
+    const store = createMemoryKbStore();
+    const kb = createMemoryKbHandlers(store);
+
+    await kb.createRule({ id: 'rule_eu', jurisdiction: 'EU', topicKey: 'tax' });
+    await kb.createRule({ id: 'rule_fr', jurisdiction: 'FR', topicKey: 'tax' });
+
+    const euDraft = await kb.upsertRuleVersion({
+      ruleId: 'rule_eu',
+      content: 'EU rule content',
+      sourceRefs: [{ sourceDocumentId: 'src1' }],
+    });
+    const frDraft = await kb.upsertRuleVersion({
+      ruleId: 'rule_fr',
+      content: 'FR rule content',
+      sourceRefs: [{ sourceDocumentId: 'src2' }],
+    });
+
+    const euApproved = await kb.approveRuleVersion({
+      ruleVersionId: euDraft.id,
+      approver: 'expert_1',
+    });
+    await kb.approveRuleVersion({
+      ruleVersionId: frDraft.id,
+      approver: 'expert_1',
+    });
+
+    const snapshot = await kb.publishSnapshot({
+      jurisdiction: 'EU',
+      asOfDate: new Date('2026-01-01T00:00:00.000Z'),
+    });
+
+    expect(snapshot.includedRuleVersionIds).toEqual([euApproved.id]);
+  });
+
+  it('search is scoped to snapshot + jurisdiction', async () => {
+    const store = createMemoryKbStore();
+    const kb = createMemoryKbHandlers(store);
+
+    await kb.createRule({
+      id: 'rule_eu',
+      jurisdiction: 'EU',
+      topicKey: 'topic',
+    });
+    const euDraft = await kb.upsertRuleVersion({
+      ruleId: 'rule_eu',
+      content: 'This is about reporting obligations',
+      sourceRefs: [{ sourceDocumentId: 'src1' }],
+    });
+    await kb.approveRuleVersion({ ruleVersionId: euDraft.id, approver: 'u1' });
+    const snap = await kb.publishSnapshot({
+      jurisdiction: 'EU',
+      asOfDate: new Date('2026-01-01T00:00:00.000Z'),
+    });
+
+    await expect(
+      kb.search({ snapshotId: snap.id, jurisdiction: 'FR', query: 'reporting' })
+    ).rejects.toThrow('JURISDICTION_MISMATCH');
+
+    const ok = await kb.search({
+      snapshotId: snap.id,
+      jurisdiction: 'EU',
+      query: 'reporting',
+    });
+    expect(ok.items.map((i) => i.ruleVersionId)).toEqual([euDraft.id]);
+  });
+});

package/src/handlers/memory.handlers.ts

@@ -0,0 +1,216 @@
+interface SourceRef {
+  sourceDocumentId: string;
+  excerpt?: string;
+}
+interface SourceDocument {
+  id: string;
+  jurisdiction: string;
+  authority: string;
+  title: string;
+  fetchedAt: Date;
+  hash: string;
+  fileId: string;
+}
+interface Rule {
+  id: string;
+  jurisdiction: string;
+  topicKey: string;
+}
+interface RuleVersion {
+  id: string;
+  ruleId: string;
+  jurisdiction: string;
+  topicKey: string;
+  version: string;
+  content: string;
+  sourceRefs: SourceRef[];
+  status: 'draft' | 'approved' | 'rejected';
+  approvedBy?: string;
+  approvedAt?: Date;
+  createdAt: Date;
+}
+interface KBSnapshot {
+  id: string;
+  jurisdiction: string;
+  asOfDate: Date;
+  includedRuleVersionIds: string[];
+  publishedAt: Date;
+}
+
+export interface MemoryKbStore {
+  sources: Map<string, SourceDocument>;
+  rules: Map<string, Rule>;
+  ruleVersions: Map<string, RuleVersion>;
+  snapshots: Map<string, KBSnapshot>;
+  nextRuleVersionNumberByRuleId: Map<string, number>;
+}
+
+export function createMemoryKbStore(): MemoryKbStore {
+  return {
+    sources: new Map(),
+    rules: new Map(),
+    ruleVersions: new Map(),
+    snapshots: new Map(),
+    nextRuleVersionNumberByRuleId: new Map(),
+  };
+}
+
+export interface MemoryKbHandlers {
+  createRule(rule: Rule): Promise<Rule>;
+  ingestSource(input: Omit<SourceDocument, 'id'>): Promise<SourceDocument>;
+  upsertRuleVersion(input: {
+    ruleId: string;
+    content: string;
+    sourceRefs: SourceRef[];
+  }): Promise<RuleVersion>;
+  approveRuleVersion(input: {
+    ruleVersionId: string;
+    approver: string;
+  }): Promise<RuleVersion>;
+  publishSnapshot(input: {
+    jurisdiction: string;
+    asOfDate: Date;
+  }): Promise<KBSnapshot>;
+  search(input: {
+    snapshotId: string;
+    jurisdiction: string;
+    query: string;
+  }): Promise<{ items: { ruleVersionId: string; excerpt?: string }[] }>;
+}
+
+function stableId(prefix: string, value: string): string {
+  return `${prefix}_${value.replace(/[^a-zA-Z0-9_-]/g, '_')}`;
+}
+
+export function createMemoryKbHandlers(store: MemoryKbStore): MemoryKbHandlers {
+  async function createRule(rule: Rule): Promise<Rule> {
+    store.rules.set(rule.id, rule);
+    return rule;
+  }
+
+  async function ingestSource(
+    input: Omit<SourceDocument, 'id'>
+  ): Promise<SourceDocument> {
+    const id = stableId('src', `${input.jurisdiction}_${input.hash}`);
+    const doc: SourceDocument = { id, ...input };
+    store.sources.set(id, doc);
+    return doc;
+  }
+
+  async function upsertRuleVersion(input: {
+    ruleId: string;
+    content: string;
+    sourceRefs: SourceRef[];
+  }): Promise<RuleVersion> {
+    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;
+    const id = stableId('rv', `${input.ruleId}_${next}`);
+    const ruleVersion: RuleVersion = {
+      id,
+      ruleId: input.ruleId,
+      jurisdiction: rule.jurisdiction,
+      topicKey: rule.topicKey,
+      version: next.toString(),
+      content: input.content,
+      sourceRefs: input.sourceRefs,
+      status: 'draft',
+      createdAt: new Date(),
+      approvedAt: undefined,
+      approvedBy: undefined,
+    };
+    store.ruleVersions.set(id, ruleVersion);
+    return ruleVersion;
+  }
+
+  async function approveRuleVersion(input: {
+    ruleVersionId: string;
+    approver: string;
+  }): Promise<RuleVersion> {
+    const existing = store.ruleVersions.get(input.ruleVersionId);
+    if (!existing) {
+      throw new Error('RULE_VERSION_NOT_FOUND');
+    }
+    const approved: RuleVersion = {
+      ...existing,
+      status: 'approved',
+      approvedBy: input.approver,
+      approvedAt: new Date(),
+    };
+    store.ruleVersions.set(approved.id, approved);
+    return approved;
+  }
+
+  async function publishSnapshot(input: {
+    jurisdiction: string;
+    asOfDate: Date;
+  }): Promise<KBSnapshot> {
+    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: KBSnapshot = {
+      id,
+      jurisdiction: input.jurisdiction,
+      asOfDate: input.asOfDate,
+      includedRuleVersionIds,
+      publishedAt: new Date(),
+    };
+    store.snapshots.set(id, snapshot);
+    return snapshot;
+  }
+
+  async function search(input: {
+    snapshotId: string;
+    jurisdiction: string;
+    query: string;
+  }): Promise<{ items: { ruleVersionId: string; excerpt?: string }[] }> {
+    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 q = input.query.toLowerCase();
+    const tokens = q
+      .split(/\s+/)
+      .map((t) => t.trim())
+      .filter(Boolean);
+    const items = snapshot.includedRuleVersionIds
+      .map((id) => store.ruleVersions.get(id))
+      .filter((rv): rv is RuleVersion => 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 { items };
+  }
+
+  return {
+    createRule,
+    ingestSource,
+    upsertRuleVersion,
+    approveRuleVersion,
+    publishSnapshot,
+    search,
+  };
+}

package/src/index.ts

@@ -0,0 +1,13 @@
+/**
+ * Versioned Knowledge Base Example
+ *
+ * Curated KB with immutable sources, reviewable rule versions, and published snapshots.
+ */
+export * from './entities';
+export * from './operations';
+export * from './events';
+export * from './handlers';
+export * from './versioned-knowledge-base.feature';
+export { default as example } from './example';
+
+import './docs';

package/src/operations/index.ts

@@ -0,0 +1 @@
+export * from './kb';