@peers-app/peers-sdk 0.1.4

package/dist/data/group-share.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateGroupShare = generateGroupShare;
+exports.validateGroupShare = validateGroupShare;
+exports.estimateGroupShareSize = estimateGroupShareSize;
+exports.checkQRCodeCompatibility = checkQRCodeCompatibility;
+exports.copyToClipboard = copyToClipboard;
+const __1 = require("..");
+const user_context_singleton_1 = require("../context/user-context-singleton");
+const group_member_roles_1 = require("./group-member-roles");
+const group_members_1 = require("./group-members");
+const groups_1 = require("./groups");
+/**
+ * Generates a GroupShare object containing the group and its admin+ members
+ * @param groupId The ID of the group to share
+ * @returns Promise<GroupShare> The shareable group data
+ * @throws Error if group not found or user lacks permission
+ */
+async function generateGroupShare(groupId) {
+    const userContext = await (0, user_context_singleton_1.getUserContext)();
+    // Get the group from user's context
+    const group = await (0, groups_1.Groups)(userContext.userDataContext).get(groupId);
+    if (!group) {
+        throw new Error('Group not found');
+    }
+    // Get group data context and members
+    const groupDataContext = userContext.getDataContext(groupId);
+    const groupMembersTable = (0, group_members_1.GroupMembers)(groupDataContext);
+    // Get the 5 newest admins to seed the members table with for the initial connection
+    const adminMembers = await groupMembersTable.list({ deleted: { $ne: true }, role: { $gte: group_member_roles_1.GroupMemberRole.Admin } }, { pageSize: 5, sortBy: ['-groupMemberId'] });
+    if (adminMembers.length === 0) {
+        console.warn('No admin members, first connection will rely exclusively on founder');
+    }
+    const groupShare = {
+        group,
+        groupMembers: adminMembers,
+    };
+    return groupShare;
+}
+/**
+ * Imports a GroupShare object, creating the group and seeding admin members
+ * @param groupShareJson JSON string containing the GroupShare data
+ * @returns Promise<string> The imported group ID
+ * @throws Error if JSON invalid or import fails
+ */
+async function importGroupShare(groupShareJson) {
+    // Parse and validate JSON
+    let groupShare;
+    try {
+        groupShare = JSON.parse(groupShareJson);
+    }
+    catch (error) {
+        throw new Error('Invalid JSON format');
+    }
+    // Validate structure - maybe redo this with a zod schema
+    if (!validateGroupShare(groupShare)) {
+        throw new Error('Invalid GroupShare structure');
+    }
+    const userContext = await (0, user_context_singleton_1.getUserContext)();
+    const { group, groupMembers } = groupShare;
+    // Check if group already exists
+    const existingGroup = await (0, groups_1.Groups)(userContext.userDataContext).get(group.groupId);
+    if (existingGroup) {
+        throw new Error(`Group "${group.name}" already exists`);
+    }
+    // Save group to user's groups table
+    await (0, groups_1.Groups)(userContext.userDataContext).save(group, { restoreIfDeleted: true });
+    // Get group data context for the new group
+    const groupDataContext = userContext.getDataContext(group.groupId);
+    // Save the group data to the group's own context
+    const groupsTable = (0, groups_1.Groups)(groupDataContext);
+    const groupsTableDataSource = getLowestDataSource(groupsTable);
+    await groupsTableDataSource.save(group);
+    // Save all admin members as seed data for device recognition
+    const groupMembersTable = (0, group_members_1.GroupMembers)(groupDataContext);
+    const groupMembersDataSource = getLowestDataSource(groupMembersTable);
+    for (const member of groupMembers) {
+        await groupMembersDataSource.save(member);
+    }
+    return group.groupId;
+}
+/**
+ * Validates that an object has the correct GroupShare structure
+ * @param obj Object to validate
+ * @returns boolean True if valid GroupShare structure
+ */
+function validateGroupShare(obj) {
+    if (!obj || typeof obj !== 'object') {
+        return false;
+    }
+    // Check group structure
+    if (!obj.group || typeof obj.group !== 'object') {
+        return false;
+    }
+    const group = obj.group;
+    if (!group.groupId || !group.name || typeof group.groupId !== 'string' || typeof group.name !== 'string') {
+        return false;
+    }
+    // Check groupMembers structure
+    if (!Array.isArray(obj.groupMembers)) {
+        return false;
+    }
+    for (const member of obj.groupMembers) {
+        if (!member || typeof member !== 'object') {
+            return false;
+        }
+        if (!member.groupMemberId || !member.groupId || !member.userId ||
+            typeof member.groupMemberId !== 'string' ||
+            typeof member.groupId !== 'string' ||
+            typeof member.userId !== 'string' ||
+            typeof member.role !== 'number' ||
+            member.role < group_member_roles_1.GroupMemberRole.Admin) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Estimates the size of a GroupShare object when serialized to JSON
+ * @param groupShare The GroupShare object to estimate
+ * @returns number Estimated size in characters
+ */
+function estimateGroupShareSize(groupShare) {
+    return JSON.stringify(groupShare).length;
+}
+/**
+ * Checks if a GroupShare object would fit in a QR code of the specified version
+ * @param groupShare The GroupShare object to check
+ * @param qrVersion QR code version (10, 20, or 40)
+ * @returns Object with size info and QR code compatibility
+ */
+function checkQRCodeCompatibility(groupShare, qrVersion = 20) {
+    const size = estimateGroupShareSize(groupShare);
+    const limits = {
+        10: 1273, // Version 10 limit
+        20: 3057, // Version 20 limit  
+        40: 7089 // Version 40 limit
+    };
+    const maxSize = limits[qrVersion];
+    const fits = size <= maxSize;
+    const usagePercent = Math.round((size / maxSize) * 100);
+    return {
+        size,
+        maxSize,
+        fits,
+        usagePercent,
+        qrVersion,
+        memberCount: groupShare.groupMembers.length
+    };
+}
+/**
+ * Copies text to clipboard with fallback handling
+ * @param text Text to copy to clipboard
+ * @returns Promise<boolean> True if successful
+ */
+async function copyToClipboard(text) {
+    try {
+        if (navigator.clipboard && navigator.clipboard.writeText) {
+            await navigator.clipboard.writeText(text);
+            return true;
+        }
+        else {
+            // Fallback for older browsers
+            const textArea = document.createElement('textarea');
+            textArea.value = text;
+            textArea.style.position = 'fixed';
+            textArea.style.opacity = '0';
+            document.body.appendChild(textArea);
+            textArea.focus();
+            textArea.select();
+            const success = document.execCommand('copy');
+            document.body.removeChild(textArea);
+            return success;
+        }
+    }
+    catch (error) {
+        console.error('Failed to copy to clipboard:', error);
+        return false;
+    }
+}
+// get around circular dependency issue
+setTimeout(async () => {
+    __1.rpcServerCalls.importGroupShare = (groupShareJson) => importGroupShare(groupShareJson);
+}, 10);
+function getLowestDataSource(table) {
+    let ds = table.dataSource;
+    for (let i = 0; i < 100; i++) {
+        if (ds.dataSource) {
+            ds = ds.dataSource;
+        }
+        else {
+            break;
+        }
+    }
+    return ds;
+}

package/dist/data/groups.d.ts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import type { DataContext } from "../context/data-context";
+import { GroupMemberRole } from "./group-member-roles";
+import { ISaveOptions, Table } from "./orm";
+export declare const groupSchema: z.ZodObject<{
+    groupId: z.ZodEffects<z.ZodString, string, string>;
+    name: z.ZodString;
+    description: z.ZodString;
+    iconClassName: z.ZodOptional<z.ZodString>;
+    publicRole: z.ZodOptional<z.ZodNativeEnum<typeof GroupMemberRole>>;
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    founderUserId: z.ZodString;
+    signature: z.ZodString;
+    publicKey: z.ZodString;
+    publicBoxKey: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    signature: string;
+    publicKey: string;
+    groupId: string;
+    founderUserId: string;
+    publicBoxKey: string;
+    disabled?: boolean | undefined;
+    iconClassName?: string | undefined;
+    publicRole?: GroupMemberRole | undefined;
+}, {
+    name: string;
+    description: string;
+    signature: string;
+    publicKey: string;
+    groupId: string;
+    founderUserId: string;
+    publicBoxKey: string;
+    disabled?: boolean | undefined;
+    iconClassName?: string | undefined;
+    publicRole?: GroupMemberRole | undefined;
+}>;
+export type IGroup = z.infer<typeof groupSchema>;
+export declare const groupsTableName = "Groups";
+export declare class GroupsTable extends Table<IGroup> {
+    static isPassthrough: boolean;
+    save(group: IGroup, opts?: ISaveOptions): Promise<IGroup>;
+    delete(groupId: string): Promise<void>;
+    /** @deprecated Direct inserts forbidden; use save() */
+    insert(..._args: Parameters<Table<IGroup>['insert']>): never;
+    /** @deprecated Direct updates forbidden; use save() */
+    update(..._args: Parameters<Table<IGroup>['update']>): never;
+}
+export declare function Groups(dataContext?: DataContext): GroupsTable;

package/dist/data/groups.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupsTable = exports.groupsTableName = exports.groupSchema = void 0;
+exports.Groups = Groups;
+const zod_1 = require("zod");
+const user_context_singleton_1 = require("../context/user-context-singleton");
+const zod_types_1 = require("../types/zod-types");
+const group_member_roles_1 = require("./group-member-roles");
+const group_permissions_1 = require("./group-permissions");
+const orm_1 = require("./orm");
+const table_definitions_system_1 = require("./orm/table-definitions.system");
+const types_1 = require("./orm/types");
+exports.groupSchema = zod_1.z.object({
+    groupId: zod_types_1.zodPeerId,
+    name: zod_1.z.string(),
+    description: zod_1.z.string(),
+    iconClassName: zod_1.z.string().optional().describe('Icon class name for the group (e.g., bi-people-fill)'),
+    publicRole: zod_1.z.nativeEnum(group_member_roles_1.GroupMemberRole).optional().describe('Whether the group is publicly readable'),
+    disabled: zod_1.z.boolean().optional().describe('Whether the group is currently disabled'),
+    founderUserId: zod_1.z.string().describe('The user ID of the group founder'),
+    signature: zod_1.z.string().describe('The signed hash of this data excluding the signature itself'),
+    publicKey: zod_1.z.string().describe('The public key of the group used to verify a data has come from a group member with write permissions or higher'),
+    publicBoxKey: zod_1.z.string().describe('The public key used to encrypt data that only group members with writer permissions or higher can decrypt'),
+});
+exports.groupsTableName = 'Groups';
+const metaData = {
+    name: exports.groupsTableName,
+    description: 'groups',
+    primaryKeyName: 'groupId',
+    fields: (0, types_1.schemaToFields)(exports.groupSchema),
+    iconClassName: 'bi bi-people-fill',
+    indexes: [
+        { fields: ['name'] },
+    ]
+};
+class GroupsTable extends orm_1.Table {
+    static isPassthrough = false;
+    async save(group, opts) {
+        if (GroupsTable.isPassthrough) {
+            return super.save(group, opts);
+        }
+        const userContext = await (0, user_context_singleton_1.getUserContext)();
+        const userContextGroups = Groups(userContext.userDataContext);
+        if (userContextGroups === this) {
+            // users can do whatever they want to groups in their personal space
+            return super.save(group, opts);
+        }
+        const oldGroup = await this.get(group.groupId);
+        await (0, group_permissions_1.verifyGroupSignature)(group, oldGroup);
+        return super.save(group, opts);
+    }
+    async delete(groupId) {
+        const userContext = await (0, user_context_singleton_1.getUserContext)();
+        const userContextGroups = Groups(userContext.userDataContext);
+        if (userContextGroups === this) {
+            return super.delete(groupId);
+        }
+        throw new Error('Only deleting groups from the user context Groups table is allowed');
+    }
+    /** @deprecated Direct inserts forbidden; use save() */
+    insert(..._args) {
+        throw new Error('Direct inserts forbidden; use save()');
+    }
+    /** @deprecated Direct updates forbidden; use save() */
+    update(..._args) {
+        throw new Error('Direct updates forbidden; use save()');
+    }
+}
+exports.GroupsTable = GroupsTable;
+(0, table_definitions_system_1.registerSystemTableDefinition)(metaData, exports.groupSchema, GroupsTable);
+function Groups(dataContext) {
+    return (0, user_context_singleton_1.getTableContainer)(dataContext).getTable(metaData, exports.groupSchema, GroupsTable);
+}

package/dist/data/groups.test.d.ts

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

package/dist/data/groups.test.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const keys_1 = require("../keys");
+const group_member_roles_1 = require("./group-member-roles");
+// Test the signature logic directly without full ORM dependencies
+describe('Groups Signature Logic', () => {
+    let testGroup;
+    let ownerKeys;
+    let adminKeys;
+    let unauthorizedKeys;
+    beforeEach(() => {
+        ownerKeys = (0, keys_1.newKeys)();
+        adminKeys = (0, keys_1.newKeys)();
+        unauthorizedKeys = (0, keys_1.newKeys)();
+        testGroup = {
+            groupId: 'test-group-1',
+            name: 'Test Group',
+            description: 'A test group',
+            publicRole: group_member_roles_1.GroupMemberRole.Reader,
+            disabled: false,
+            signature: '',
+            founderUserId: '',
+            publicKey: ownerKeys.publicKey,
+            publicBoxKey: ownerKeys.publicKey
+        };
+    });
+    describe('basic signature functionality', () => {
+        it('should add signature to group object', () => {
+            const signedGroup = (0, keys_1.addSignatureToObject)(testGroup, ownerKeys.secretKey);
+            expect(signedGroup.signature).toBeTruthy();
+            expect(signedGroup.signature).toContain(':');
+            expect(signedGroup.name).toBe(testGroup.name);
+            expect(signedGroup.groupId).toBe(testGroup.groupId);
+        });
+        it('should verify valid signature', () => {
+            const signedGroup = (0, keys_1.addSignatureToObject)(testGroup, ownerKeys.secretKey);
+            const isValid = (0, keys_1.isObjectSignatureValid)(signedGroup);
+            expect(isValid).toBe(true);
+        });
+        it('should reject invalid signature after modification', () => {
+            const signedGroup = (0, keys_1.addSignatureToObject)(testGroup, ownerKeys.secretKey);
+            // Modify the group after signing
+            signedGroup.name = 'Modified Name';
+            const isValid = (0, keys_1.isObjectSignatureValid)(signedGroup);
+            expect(isValid).toBe(false);
+        });
+        it('should extract correct public key from signature', () => {
+            const signedGroup = (0, keys_1.addSignatureToObject)(testGroup, ownerKeys.secretKey);
+            const extractedKey = (0, keys_1.getPublicKeyFromObjectSignature)(signedGroup);
+            expect(extractedKey).toBe(ownerKeys.publicKey);
+        });
+    });
+    describe('basic signing with different keys', () => {
+        it('should create valid signature with owner key', () => {
+            const signedGroup = (0, keys_1.addSignatureToObject)(testGroup, ownerKeys.secretKey);
+            const extractedKey = (0, keys_1.getPublicKeyFromObjectSignature)(signedGroup);
+            expect(extractedKey).toBe(ownerKeys.publicKey);
+            expect((0, keys_1.isObjectSignatureValid)(signedGroup)).toBe(true);
+        });
+        it('should create valid signature with admin key', () => {
+            const signedGroup = (0, keys_1.addSignatureToObject)(testGroup, adminKeys.secretKey);
+            const extractedKey = (0, keys_1.getPublicKeyFromObjectSignature)(signedGroup);
+            expect(extractedKey).toBe(adminKeys.publicKey);
+            expect((0, keys_1.isObjectSignatureValid)(signedGroup)).toBe(true);
+        });
+        it('should create valid signature with any key', () => {
+            const signedGroup = (0, keys_1.addSignatureToObject)(testGroup, unauthorizedKeys.secretKey);
+            const extractedKey = (0, keys_1.getPublicKeyFromObjectSignature)(signedGroup);
+            expect(extractedKey).toBe(unauthorizedKeys.publicKey);
+            expect((0, keys_1.isObjectSignatureValid)(signedGroup)).toBe(true); // Signature is cryptographically valid
+        });
+    });
+    describe('signature tampering detection', () => {
+        it('should detect tampered signature', () => {
+            const signedGroup = (0, keys_1.addSignatureToObject)(testGroup, ownerKeys.secretKey);
+            // Tamper with signature by adding extra characters
+            signedGroup.signature = signedGroup.signature + 'tampered';
+            expect((0, keys_1.isObjectSignatureValid)(signedGroup)).toBe(false);
+        });
+        it('should detect empty signature', () => {
+            testGroup.signature = '';
+            expect((0, keys_1.isObjectSignatureValid)(testGroup)).toBe(false);
+        });
+        it('should detect malformed signature', () => {
+            testGroup.signature = 'malformed-signature';
+            expect((0, keys_1.isObjectSignatureValid)(testGroup)).toBe(false);
+        });
+        it('should handle signature without colon separator', () => {
+            testGroup.signature = 'noseparator';
+            expect((0, keys_1.isObjectSignatureValid)(testGroup)).toBe(false);
+            expect((0, keys_1.getPublicKeyFromObjectSignature)(testGroup)).toBeUndefined();
+        });
+    });
+    describe('complex group objects', () => {
+        it('should handle groups with all optional fields', () => {
+            const complexGroup = {
+                ...testGroup,
+                publicRole: group_member_roles_1.GroupMemberRole.Writer,
+                disabled: true,
+            };
+            const signedGroup = (0, keys_1.addSignatureToObject)(complexGroup, ownerKeys.secretKey);
+            expect((0, keys_1.isObjectSignatureValid)(signedGroup)).toBe(true);
+            expect(signedGroup.publicRole).toBe(group_member_roles_1.GroupMemberRole.Writer);
+            expect(signedGroup.disabled).toBe(true);
+        });
+        it('should handle groups without optional fields', () => {
+            const simpleGroup = {
+                groupId: testGroup.groupId,
+                name: testGroup.name,
+                description: testGroup.description,
+                signature: '',
+                founderUserId: '',
+                publicKey: ownerKeys.publicKey,
+                publicBoxKey: ownerKeys.publicKey
+            };
+            const signedGroup = (0, keys_1.addSignatureToObject)(simpleGroup, ownerKeys.secretKey);
+            expect((0, keys_1.isObjectSignatureValid)(signedGroup)).toBe(true);
+            expect(signedGroup.publicRole).toBeUndefined();
+            expect(signedGroup.disabled).toBeUndefined();
+        });
+    });
+    describe('edge cases', () => {
+        it('should handle long group names and descriptions', () => {
+            const longGroup = {
+                ...testGroup,
+                name: 'A'.repeat(1000),
+                description: 'B'.repeat(5000),
+            };
+            const signedGroup = (0, keys_1.addSignatureToObject)(longGroup, ownerKeys.secretKey);
+            expect((0, keys_1.isObjectSignatureValid)(signedGroup)).toBe(true);
+        });
+        it('should handle special characters in group data', () => {
+            const specialGroup = {
+                ...testGroup,
+                name: 'Group with 🚀 emojis and "quotes" & <html>',
+                description: 'Contains\nnewlines\tand\ttabs',
+            };
+            const signedGroup = (0, keys_1.addSignatureToObject)(specialGroup, ownerKeys.secretKey);
+            expect((0, keys_1.isObjectSignatureValid)(signedGroup)).toBe(true);
+            expect(signedGroup.name).toContain('🚀');
+            expect(signedGroup.description).toContain('\n');
+        });
+        it('should handle empty strings', () => {
+            const emptyGroup = {
+                ...testGroup,
+                name: '',
+                description: '',
+            };
+            const signedGroup = (0, keys_1.addSignatureToObject)(emptyGroup, ownerKeys.secretKey);
+            expect((0, keys_1.isObjectSignatureValid)(signedGroup)).toBe(true);
+        });
+    });
+});

package/dist/data/index.d.ts

@@ -0,0 +1,31 @@
+export * from "./assistants";
+export * from "./channels";
+export * from "./change-tracking";
+export * from "./data-locks";
+export * from "./device-sync-info";
+export * from "./devices";
+export * from "./embeddings";
+export * from "./files";
+export * from "./group-permissions";
+export * from "./groups";
+export * from "./group-members";
+export * from "./group-member-roles";
+export * from "./group-share";
+export * from "./knowledge/knowledge-frames";
+export * from "./knowledge/knowledge-links";
+export * from "./knowledge/knowledge-values";
+export * from "./knowledge/peer-types";
+export * from "./knowledge/predicates";
+export * from "./messages";
+export * from "./packages";
+export * from "./peer-events/peer-event-handlers";
+export * from "./peer-events/peer-event-types";
+export * from "./peer-events/peer-events";
+export * from "./persistent-vars";
+export * from "./tool-tests";
+export * from "./tools";
+export * from "./users";
+export * from "./user-permissions";
+export * from "./workflow-logs";
+export * from "./workflow-runs";
+export * from "./workflows";

package/dist/data/index.js

@@ -0,0 +1,47 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./assistants"), exports);
+__exportStar(require("./channels"), exports);
+__exportStar(require("./change-tracking"), exports);
+__exportStar(require("./data-locks"), exports);
+__exportStar(require("./device-sync-info"), exports);
+__exportStar(require("./devices"), exports);
+__exportStar(require("./embeddings"), exports);
+__exportStar(require("./files"), exports);
+__exportStar(require("./group-permissions"), exports);
+__exportStar(require("./groups"), exports);
+__exportStar(require("./group-members"), exports);
+__exportStar(require("./group-member-roles"), exports);
+__exportStar(require("./group-share"), exports);
+__exportStar(require("./knowledge/knowledge-frames"), exports);
+__exportStar(require("./knowledge/knowledge-links"), exports);
+__exportStar(require("./knowledge/knowledge-values"), exports);
+__exportStar(require("./knowledge/peer-types"), exports);
+__exportStar(require("./knowledge/predicates"), exports);
+__exportStar(require("./messages"), exports);
+__exportStar(require("./packages"), exports);
+__exportStar(require("./peer-events/peer-event-handlers"), exports);
+__exportStar(require("./peer-events/peer-event-types"), exports);
+__exportStar(require("./peer-events/peer-events"), exports);
+__exportStar(require("./persistent-vars"), exports);
+__exportStar(require("./tool-tests"), exports);
+__exportStar(require("./tools"), exports);
+__exportStar(require("./users"), exports);
+__exportStar(require("./user-permissions"), exports);
+__exportStar(require("./workflow-logs"), exports);
+__exportStar(require("./workflow-runs"), exports);
+__exportStar(require("./workflows"), exports);

package/dist/data/knowledge/knowledge-frames.d.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import type { DataContext } from "../../context/data-context";
+declare const knowledgeFrameSchema: z.ZodObject<{
+    knowledgeFrameId: z.ZodEffects<z.ZodString, string, string>;
+    name: z.ZodString;
+    body: z.ZodString;
+    conclusion: z.ZodOptional<z.ZodString>;
+    knowledgeValueIds: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
+    modified: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    body: string;
+    knowledgeFrameId: string;
+    knowledgeValueIds: string[];
+    modified: number;
+    conclusion?: string | undefined;
+}, {
+    name: string;
+    body: string;
+    knowledgeFrameId: string;
+    knowledgeValueIds: string[];
+    modified: number;
+    conclusion?: string | undefined;
+}>;
+export type IKnowledgeFrame = z.infer<typeof knowledgeFrameSchema>;
+export declare function KnowledgeFrames(dataContext?: DataContext): import("../orm").Table<{
+    name: string;
+    body: string;
+    knowledgeFrameId: string;
+    knowledgeValueIds: string[];
+    modified: number;
+    conclusion?: string | undefined;
+}>;
+export {};

package/dist/data/knowledge/knowledge-frames.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnowledgeFrames = KnowledgeFrames;
+const zod_1 = require("zod");
+const types_1 = require("../orm/types");
+const user_context_singleton_1 = require("../../context/user-context-singleton");
+const table_definitions_system_1 = require("../orm/table-definitions.system");
+const zod_types_1 = require("../../types/zod-types");
+// Think of a knowledge frame as like a "hub note" in Roam Research
+// besides just linking content together with a central topic, 
+// it is also a way to explore and idea by surfacing new links and generating new knowledge values
+const knowledgeFrameSchema = zod_1.z.object({
+    knowledgeFrameId: zod_types_1.zodPeerId,
+    name: zod_1.z.string().describe('The name or topic of the knowledge frame'),
+    body: zod_1.z.string().describe('Describe the purpose / thesis / goal of the knowledge frame'),
+    conclusion: zod_1.z.string().optional().describe('The conclusion of the knowledge frame'),
+    knowledgeValueIds: zod_types_1.zodPeerId.array().describe('The knowledge values that are included in the frame'),
+    // knowledgeLinkIds: zodPeerId.array().describe('The knowledge links that are allowed in the frame'),
+    // excludedValueIds: zodPeerId.array().describe('The knowledge values that are explicitly excluded from the frame'),
+    // allowedPredicateIds: zodPeerId.array().describe('The predicates that are allowed in the frame'),
+    // allowedpeerTypeIds: zodPeerId.array().describe('The value types that are allowed in the frame'),
+    modified: zod_1.z.number().describe('The last time the frame was modified'),
+});
+const metaData = {
+    name: 'KnowledgeFrames',
+    description: "The knowledge frames in the system",
+    primaryKeyName: 'knowledgeFrameId',
+    fields: (0, types_1.schemaToFields)(knowledgeFrameSchema),
+    iconClassName: 'bi bi-window-dock',
+};
+(0, table_definitions_system_1.registerSystemTableDefinition)(metaData, knowledgeFrameSchema);
+function KnowledgeFrames(dataContext) {
+    return (0, user_context_singleton_1.getTableContainer)(dataContext).getTable(metaData, knowledgeFrameSchema);
+}

package/dist/data/knowledge/knowledge-links.d.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import type { DataContext } from "../../context/data-context";
+declare const knowledgeLinkSchema: z.ZodObject<{
+    knowledgeLinkId: z.ZodEffects<z.ZodString, string, string>;
+    subjectValueId: z.ZodEffects<z.ZodString, string, string>;
+    predicateId: z.ZodEffects<z.ZodString, string, string>;
+    predicateValue: z.ZodAny;
+    objectValueId: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+}, "strip", z.ZodTypeAny, {
+    knowledgeLinkId: string;
+    subjectValueId: string;
+    predicateId: string;
+    predicateValue?: any;
+    objectValueId?: string | undefined;
+}, {
+    knowledgeLinkId: string;
+    subjectValueId: string;
+    predicateId: string;
+    predicateValue?: any;
+    objectValueId?: string | undefined;
+}>;
+export type IKnowledgeLink = z.infer<typeof knowledgeLinkSchema>;
+export declare function KnowledgeLinks(dataContext?: DataContext): import("../orm").Table<{
+    knowledgeLinkId: string;
+    subjectValueId: string;
+    predicateId: string;
+    predicateValue?: any;
+    objectValueId?: string | undefined;
+}>;
+export {};