@ericsanchezok/synergy-util 3.0.24 → 3.1.0

package/dist/workbench-view.js

@@ -0,0 +1,90 @@
+import { z } from "zod";
+import { AssetReference } from "./asset-reference";
+import { ResourceReference } from "./resource-reference";
+export var WorkbenchView;
+(function (WorkbenchView) {
+    WorkbenchView.VERSION = 1;
+    const identity = z.string().min(1);
+    WorkbenchView.TargetKind = z.enum(["note", "workspace-file", "browser-page", "asset"]);
+    WorkbenchView.Target = z.discriminatedUnion("kind", [
+        z.object({ kind: z.literal("note"), id: identity, location: ResourceReference.Location.optional() }).strict(),
+        z
+            .object({ kind: z.literal("workspace-file"), path: identity, location: ResourceReference.Location.optional() })
+            .strict(),
+        z.object({ kind: z.literal("browser-page"), pageId: identity }).strict(),
+        z
+            .object({
+            kind: z.literal("asset"),
+            url: identity.refine((value) => AssetReference.parse(value)?.url === value, "Use an immutable asset:// reference."),
+            location: ResourceReference.Location.optional(),
+        })
+            .strict(),
+    ]);
+    WorkbenchView.Command = z.discriminatedUnion("action", [
+        z.object({ action: z.literal("open"), target: WorkbenchView.Target }).strict(),
+        z.object({ action: z.literal("hide"), viewId: identity }).strict(),
+        z.object({ action: z.literal("status"), requestId: identity.optional() }).strict(),
+    ]);
+    WorkbenchView.Parameters = z
+        .object({
+        input: WorkbenchView.Command,
+        clientId: identity
+            .optional()
+            .describe("An eligible frontend ID returned by status when multiple frontends show this session."),
+        timeoutSeconds: z
+            .number()
+            .positive()
+            .finite()
+            .optional()
+            .describe("Seconds to wait for a frontend receipt. A missing receipt is unknown, not success."),
+    })
+        .strict();
+    WorkbenchView.View = z
+        .object({
+        viewId: identity,
+        surface: z.enum(["side", "bottom"]),
+        target: WorkbenchView.Target,
+        visible: z.boolean(),
+        contentState: z.enum(["loading", "ready", "unavailable"]),
+    })
+        .strict();
+    WorkbenchView.Client = z.object({ clientId: identity }).strict();
+    WorkbenchView.Outcome = z
+        .object({
+        status: z.enum(["applied", "unavailable", "blocked", "superseded", "unknown", "ambiguous", "cancelled"]),
+        reason: z.string().optional(),
+        views: z.array(WorkbenchView.View).optional(),
+        clients: z.array(WorkbenchView.Client).optional(),
+    })
+        .strict();
+    WorkbenchView.Result = WorkbenchView.Outcome.extend({ requestId: identity, clientId: identity.optional() });
+    WorkbenchView.Request = z
+        .object({
+        requestId: identity,
+        scopeID: identity,
+        sessionID: identity,
+        command: WorkbenchView.Command,
+        context: ResourceReference.Context.optional(),
+    })
+        .strict();
+    WorkbenchView.ServerMessage = z.discriminatedUnion("type", [
+        z.object({ type: z.literal("server.workbench.request"), properties: WorkbenchView.Request }).strict(),
+        z
+            .object({ type: z.literal("server.workbench.cancel"), properties: z.object({ requestId: identity }).strict() })
+            .strict(),
+    ]);
+    WorkbenchView.ClientMessage = z.discriminatedUnion("type", [
+        z
+            .object({
+            type: z.literal("client.workbench.ready"),
+            properties: z.object({ version: z.literal(WorkbenchView.VERSION), targets: z.array(WorkbenchView.TargetKind) }).strict(),
+        })
+            .strict(),
+        z
+            .object({
+            type: z.literal("client.workbench.receipt"),
+            properties: z.object({ requestId: identity, outcome: WorkbenchView.Outcome }).strict(),
+        })
+            .strict(),
+    ]);
+})(WorkbenchView || (WorkbenchView = {}));

package/dist/worker-plan.d.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+export declare const ComponentWorkerPlan: z.ZodObject<{
+    apiVersion: z.ZodLiteral<2>;
+    agent: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+        entry: z.ZodString;
+    }, z.core.$strict>>;
+    policy: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+        entry: z.ZodString;
+    }, z.core.$strict>>;
+    features: z.ZodObject<{
+        definitions: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            owner: z.ZodString;
+            maturity: z.ZodEnum<{
+                experimental: "experimental";
+                stable: "stable";
+            }>;
+            activation: z.ZodEnum<{
+                live: "live";
+                restart: "restart";
+            }>;
+            name: z.ZodString;
+            description: z.ZodString;
+            component: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        optIn: z.ZodArray<z.ZodString>;
+        selection: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strict>>;
+        components: z.ZodArray<z.ZodString>;
+        requirements: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type ComponentWorkerPlan = z.infer<typeof ComponentWorkerPlan>;

package/dist/worker-plan.js

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { FeaturePlan } from "./features";
+const Entry = z
+    .object({
+    id: z.string().min(1),
+    version: z.string().min(1),
+    entry: z
+        .string()
+        .url()
+        .refine((value) => new URL(value).protocol === "file:", "Worker entries must be local files"),
+})
+    .strict();
+export const ComponentWorkerPlan = z
+    .object({ apiVersion: z.literal(2), agent: z.array(Entry), policy: z.array(Entry), features: FeaturePlan })
+    .strict()
+    .superRefine((plan, context) => {
+    const versions = new Map(plan.features.selection.map(({ id, version }) => [id, version]));
+    for (const role of ["agent", "policy"]) {
+        const seen = new Set();
+        for (const entry of plan[role]) {
+            const message = seen.has(entry.id)
+                ? `Duplicate worker component: ${entry.id}`
+                : !plan.features.components.includes(entry.id)
+                    ? `Worker component is not in its host feature plan: ${entry.id}`
+                    : versions.get(entry.id) !== entry.version
+                        ? `Worker component does not match the host composition: ${entry.id}`
+                        : undefined;
+            if (message)
+                context.addIssue({ code: "custom", path: [role], message });
+            seen.add(entry.id);
+        }
+    }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ericsanchezok/synergy-util",
-  "version": "3.0.24",
+  "version": "3.1.0",
   "type": "module",
   "license": "MIT",
   "exports": {
@@ -11,6 +11,26 @@
     "./pty-keys": {
       "types": "./dist/pty-keys.d.ts",
       "import": "./dist/pty-keys.js"
+    },
+    "./terminal": {
+      "types": "./dist/terminal.d.ts",
+      "import": "./dist/terminal.js"
+    },
+    "./cli-command": {
+      "types": "./dist/cli-command.d.ts",
+      "import": "./dist/cli-command.js"
+    },
+    "./atomic-file": {
+      "types": "./dist/atomic-file.d.ts",
+      "import": "./dist/atomic-file.js"
+    },
+    "./io-retry": {
+      "types": "./dist/io-retry.d.ts",
+      "import": "./dist/io-retry.js"
+    },
+    "./installed-launcher": {
+      "types": "./dist/installed-launcher.d.ts",
+      "import": "./dist/installed-launcher.js"
     }
   },
   "scripts": {
@@ -19,9 +39,13 @@
     "test": "bun test test/*.test.ts"
   },
   "files": [
-    "dist"
+    "dist",
+    "LICENSE.codex",
+    "NOTICE"
   ],
   "dependencies": {
-    "zod": "4.1.8"
+    "jsonc-parser": "3.3.1",
+    "marked": "18.1.1",
+    "zod": "4.6.7"
   }
-}
+}