@sidurijs/core 1.0.0

package/dist/context.js

@@ -0,0 +1,85 @@
+"use strict";
+// Single-owner, single-machine context model
+// Security perimeter is the local machine boundary (external vs internal).
+// No internal audience, viewer, or owner role hierarchies.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidSubjectKind = isValidSubjectKind;
+exports.validateRequestContext = validateRequestContext;
+function isValidSubjectKind(kind) {
+    return kind === 'actor' || kind === 'companion' || kind === 'configured';
+}
+function validateRequestContext(context) {
+    if (!context || typeof context !== 'object') {
+        return {
+            accepted: false,
+            error: {
+                code: 'MISSING_CONTEXT',
+                fields: ['context'],
+            },
+        };
+    }
+    const ctx = context;
+    const missingFields = [];
+    if (!ctx.companionId || typeof ctx.companionId !== 'string' || ctx.companionId.trim() === '') {
+        missingFields.push('companionId');
+    }
+    if (!ctx.actor || typeof ctx.actor !== 'object') {
+        missingFields.push('actor');
+    }
+    else {
+        if (!ctx.actor.actorId || typeof ctx.actor.actorId !== 'string' || ctx.actor.actorId.trim() === '') {
+            missingFields.push('actor.actorId');
+        }
+        if (!ctx.actor.sessionId || typeof ctx.actor.sessionId !== 'string' || ctx.actor.sessionId.trim() === '') {
+            missingFields.push('actor.sessionId');
+        }
+    }
+    if (!ctx.conversation || typeof ctx.conversation !== 'object') {
+        missingFields.push('conversation');
+    }
+    else {
+        if (!ctx.conversation.correlationId || typeof ctx.conversation.correlationId !== 'string' || ctx.conversation.correlationId.trim() === '') {
+            missingFields.push('conversation.correlationId');
+        }
+    }
+    if (ctx.subject !== undefined) {
+        if (!ctx.subject || typeof ctx.subject !== 'object') {
+            missingFields.push('subject');
+        }
+        else {
+            if (!ctx.subject.subjectId || typeof ctx.subject.subjectId !== 'string' || ctx.subject.subjectId.trim() === '') {
+                missingFields.push('subject.subjectId');
+            }
+            if (!isValidSubjectKind(ctx.subject.kind)) {
+                missingFields.push('subject.kind');
+            }
+        }
+    }
+    if (ctx.mode !== undefined) {
+        if (ctx.mode !== 'casual' && ctx.mode !== 'teach' && ctx.mode !== 'hybrid') {
+            return {
+                accepted: false,
+                error: {
+                    code: 'INVALID_CONTEXT',
+                    message: `Invalid interaction mode: '${ctx.mode}' (expected 'casual', 'teach', or 'hybrid')`,
+                    field: 'mode',
+                    correlationId: ctx.conversation?.correlationId,
+                },
+            };
+        }
+    }
+    if (missingFields.length > 0) {
+        return {
+            accepted: false,
+            error: {
+                code: 'MISSING_CONTEXT',
+                fields: missingFields,
+                correlationId: ctx.conversation?.correlationId,
+            },
+        };
+    }
+    return {
+        accepted: true,
+        context: ctx,
+    };
+}

package/dist/context.test.d.ts

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

package/dist/context.test.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const context_1 = require("./context");
+describe('Core Context Contract (Single-Owner Single-Machine)', () => {
+    const validContext = {
+        companionId: 'companion-a',
+        actor: {
+            actorId: 'local-user',
+            sessionId: 'session-a',
+            authenticated: true,
+            capabilities: ['chat:interact'],
+        },
+        conversation: {
+            correlationId: 'corr-a',
+        },
+        subject: {
+            subjectId: 'actor:local-user',
+            kind: 'actor',
+            ownerActorId: 'local-user',
+        },
+    };
+    test('validates a correct RequestContext', () => {
+        const result = (0, context_1.validateRequestContext)(validContext);
+        expect(result.accepted).toBe(true);
+        expect(result.context).toEqual(validContext);
+        expect(result.error).toBeUndefined();
+    });
+    test('validates a correct RequestContext without subject', () => {
+        const { subject, ...contextWithoutSubject } = validContext;
+        const result = (0, context_1.validateRequestContext)(contextWithoutSubject);
+        expect(result.accepted).toBe(true);
+        expect(result.context?.subject).toBeUndefined();
+    });
+    test('rejects missing root context or non-object', () => {
+        const result = (0, context_1.validateRequestContext)(null);
+        expect(result.accepted).toBe(false);
+        expect(result.error?.code).toBe('MISSING_CONTEXT');
+        expect(result.error?.fields).toContain('context');
+    });
+    test('rejects missing companionId, actor, or conversation', () => {
+        const result = (0, context_1.validateRequestContext)({});
+        expect(result.accepted).toBe(false);
+        expect(result.error?.code).toBe('MISSING_CONTEXT');
+        expect(result.error?.fields).toEqual(expect.arrayContaining(['companionId', 'actor', 'conversation']));
+    });
+    test('validates subject kinds and constraints', () => {
+        expect((0, context_1.isValidSubjectKind)('actor')).toBe(true);
+        expect((0, context_1.isValidSubjectKind)('companion')).toBe(true);
+        expect((0, context_1.isValidSubjectKind)('configured')).toBe(true);
+        expect((0, context_1.isValidSubjectKind)('user')).toBe(false);
+        const invalidSubjectCtx = {
+            ...validContext,
+            subject: { subjectId: 'subject-1', kind: 'invalid_kind' },
+        };
+        const result = (0, context_1.validateRequestContext)(invalidSubjectCtx);
+        expect(result.accepted).toBe(false);
+        expect(result.error?.fields).toContain('subject.kind');
+    });
+    test('rejects missing correlationId and preserves correlationId in error if present', () => {
+        const missingCorr = {
+            ...validContext,
+            conversation: { ...validContext.conversation, correlationId: '' },
+        };
+        const result = (0, context_1.validateRequestContext)(missingCorr);
+        expect(result.accepted).toBe(false);
+        expect(result.error?.fields).toContain('conversation.correlationId');
+        const missingActorId = {
+            ...validContext,
+            actor: { ...validContext.actor, actorId: '' },
+        };
+        const result2 = (0, context_1.validateRequestContext)(missingActorId);
+        expect(result2.accepted).toBe(false);
+        expect(result2.error?.fields).toContain('actor.actorId');
+        expect(result2.error?.correlationId).toBe('corr-a');
+    });
+});

package/dist/conversational-teach.test.d.ts

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