@sero-ai/app-runtime 0.2.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sero-ai/app-runtime",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Hooks for Sero federated app modules — useAppState, useAppInfo, useAgentPrompt, useAppTools",
   "type": "module",
   "main": "./src/index.ts",
@@ -23,9 +23,11 @@
   "devDependencies": {
     "@types/react": "^19.2.13",
     "typescript": "^5.9.3",
-    "@sero-ai/common": "0.4.0"
+    "vitest": "^4.1.7",
+    "@sero-ai/common": "0.8.0"
   },
   "scripts": {
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
   }
 }

package/src/sero-bridge.ts

@@ -11,8 +11,6 @@ import type {
   AppToolResult,
   AvailableContext,
   ContextPreset,
-  GitActionResult,
-  GitManagerRequest,
   SharedAvailableModelGroup,
   SharedModelInfo,
   WebAppActionResult,
@@ -50,10 +48,6 @@ export interface SeroAppControlBridge {
   openFile(workspaceId: string, filePath: string): Promise<boolean>;
 }
 
-export interface SeroGitAppBridge {
-  run(workspaceId: string, params: GitManagerRequest): Promise<GitActionResult>;
-}
-
 export interface SeroWebAppBridge {
   run(workspaceId: string, params: WebAppRequest): Promise<WebAppActionResult>;
 }
@@ -96,7 +90,6 @@ export interface SeroBridge {
   appState: SeroWindowAppStateBridge;
   appAgent: SeroAppAgentBridge;
   appControl?: SeroAppControlBridge;
-  gitApp?: SeroGitAppBridge;
   webApp?: SeroWebAppBridge;
   editor?: SeroEditorBridge;
   models?: SeroModelsBridge;

package/src/use-app-state.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it } from 'vitest';
+
+import { applyDefaultState } from './use-app-state';
+
+interface DemoState {
+  name: string;
+  count: number;
+  tags: string[];
+  nested: { open: boolean };
+  optional?: { from: string };
+}
+
+const DEFAULT_STATE: DemoState = {
+  name: '',
+  count: 0,
+  tags: [],
+  nested: { open: false },
+};
+
+describe('applyDefaultState', () => {
+  it('takes the file’s values over the defaults', () => {
+    expect(applyDefaultState(DEFAULT_STATE, {
+      name: 'repo',
+      count: 3,
+      tags: ['a'],
+      nested: { open: true },
+    })).toEqual({ name: 'repo', count: 3, tags: ['a'], nested: { open: true } });
+  });
+
+  it('keeps the default where the file disagrees about the type', () => {
+    const merged = applyDefaultState(DEFAULT_STATE, { name: 42, tags: 'nope' });
+    expect(merged.name).toBe('');
+    expect(merged.tags).toEqual([]);
+  });
+
+  it('fills in what the file leaves out', () => {
+    expect(applyDefaultState(DEFAULT_STATE, { name: 'repo' }).count).toBe(0);
+  });
+
+  // An `undefined` default says the field is optional, not that it must be
+  // absent. Enforcing it dropped the file's value on every read, which is how
+  // a whole feature's state could be written correctly and never arrive.
+  it('passes optional fields through when the default is undefined', () => {
+    const withOptional: DemoState = { ...DEFAULT_STATE, optional: undefined };
+
+    expect(applyDefaultState(withOptional, {
+      name: 'repo',
+      optional: { from: 'the file' },
+    }).optional).toEqual({ from: 'the file' });
+  });
+
+  it('leaves an absent optional field absent', () => {
+    const withOptional: DemoState = { ...DEFAULT_STATE, optional: undefined };
+    expect(applyDefaultState(withOptional, { name: 'repo' }).optional).toBeUndefined();
+  });
+});

package/src/use-app-state.ts

@@ -20,7 +20,19 @@ function isPlainObject(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 
+/**
+ * The state file is merged over the app's default state key by key, and the
+ * default wins wherever the two disagree in type — a malformed file cannot
+ * hand an app a number where it expects a string.
+ *
+ * An `undefined` default is the exception: it says the field is optional, not
+ * that it must be absent. Enforcing it would drop the file's value on every
+ * read, which is exactly what used to happen to any optional field an app
+ * declared as `undefined` in its default state.
+ */
 function normalizeStateValue(defaultValue: unknown, currentValue: unknown): unknown {
+  if (defaultValue === undefined) return currentValue;
+
   if (Array.isArray(defaultValue)) {
     return Array.isArray(currentValue) ? currentValue : defaultValue;
   }
@@ -39,7 +51,11 @@ function normalizeStateValue(defaultValue: unknown, currentValue: unknown): unkn
   return typeof currentValue === typeof defaultValue ? currentValue : defaultValue;
 }
 
-function applyDefaultState<T>(defaultState: T, current: unknown): T {
+/**
+ * Merge a state file's contents over an app's default state. Exported for its
+ * tests, not from the package entry point — it is not public API.
+ */
+export function applyDefaultState<T>(defaultState: T, current: unknown): T {
   return normalizeStateValue(defaultState, current) as T;
 }