@fungi.computer/braid 0.2.4 → 0.4.0

package/dist/runtime/arming-authority.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod";
 import type { WorkflowRunMember } from "./run-authority.js";
 /** Host-captured provenance from the actual connector or approved-policy owner. */
 export declare const workflowArmedViaSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{

package/dist/runtime/arming-authority.js

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod";
 import { decodeWorkflowRunMember } from "./run-member.js";
 const identity = z.string().min(1).max(256);
 const membershipVersion = z.lazy(() => z.number().int().nonnegative());

package/dist/runtime/git-pass-contract.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod";
 import type { GitWriter } from "@fungi.computer/agar/git";
 /** One credential grammar for both hosts; the owner is public, the token is not. */
 export declare const workflowGitPassPrefix = "wgp.";

package/dist/runtime/git-pass-contract.js

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod";
 import { workflowAttestationSchema } from "@fungi.computer/puffball/app-method-runtime";
 import { gitAccessScope, resolvedGitAccessSchema } from "../git-access.js";
 const id = z.string().min(1).max(256);

package/dist/runtime/git-pass-store.js

@@ -1,5 +1,5 @@
 import { repositoryRefsEqual, } from "@fungi.computer/agar/git";
-import { z } from "zod";
+import * as z from "zod";
 import { canonicalJson } from "../index.js";
 import { formatWorkflowGitPassToken, workflowGitPassTokenSchema, workflowGitPassGrantSchema, workflowGitPassRevocationSchema, } from "./git-pass-contract.js";
 const invocationIdSchema = z.string().min(1).max(256);

package/dist/runtime/graph-start.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod";
 import * as S from "effect/Schema";
 import { type ExecutionPlan, type Issue } from "../index.js";
 import type { WorkflowCatalogEntry } from "./ports.js";

package/dist/runtime/graph-start.js

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod";
 import { bindingsSelectionSchema, workflowBindingSchema, } from "../git-access.js";
 import { gitSha1Schema } from "@fungi.computer/puffball/git-representation";
 import { sha256DigestSchema } from "@fungi.computer/puffball/effect";

package/dist/runtime/run-owner.d.ts

@@ -1,6 +1,6 @@
 import * as S from "effect/Schema";
 import { type NodeEvent, type NodeAdmissionResult } from "../execution.js";
-import { z } from "zod";
+import * as z from "zod";
 import type { WatchdogSqliteOwner } from "@fungi.computer/watchdog";
 import { type WorkflowRunAuthority } from "./run-authority.js";
 import type { ArmedWorkflowTrigger } from "./trigger-owner.js";
@@ -1584,7 +1584,7 @@ export declare function createTeamWorkflowRuns(options: {
     revokeReleaseInMutation(appIds: readonly string[]): void;
     /** The kernel's lifecycle caller owns the transaction. Suspension ends every run. */
     onLifecycle(status: "active" | "suspended"): void;
-    reserveWebhookDelivery(raw: z.input<z.ZodObject<{
+    reserveWebhookDelivery(raw: z.core.input<z.ZodObject<{
         scope: z.ZodLazy<z.ZodObject<{
             installationId: z.ZodString;
             workflowId: z.ZodString;
@@ -1610,7 +1610,7 @@ export declare function createTeamWorkflowRuns(options: {
         kind: "refused";
         reason: "limit";
     };
-    pendingWebhookDeliveries(rawOwner: z.input<z.ZodObject<{
+    pendingWebhookDeliveries(rawOwner: z.core.input<z.ZodObject<{
         host: z.ZodString;
         tenant: z.ZodString;
     }, z.core.$strict>>): ({
@@ -1639,7 +1639,7 @@ export declare function createTeamWorkflowRuns(options: {
         reservationId: string;
         runId?: never;
     })[];
-    nextWebhookWake(rawOwner: z.input<z.ZodObject<{
+    nextWebhookWake(rawOwner: z.core.input<z.ZodObject<{
         host: z.ZodString;
         tenant: z.ZodString;
     }, z.core.$strict>>): number | null;

package/dist/runtime/run-owner.js

@@ -1,7 +1,7 @@
 import * as S from "effect/Schema";
 import * as Struct from "effect/Struct";
 import { nodeEventSchema, } from "../execution.js";
-import { z } from "zod";
+import * as z from "zod";
 import { bindingsSelectionSchema, workflowBindingSchema, } from "../git-access.js";
 import { canonicalJson, contentDigest } from "../index.js";
 import { createTriggerPlans } from "./trigger-plans.js";

package/dist/runtime/schedules.d.ts

@@ -1,5 +1,12 @@
+import * as z from "zod";
 import type { WatchdogSqliteOwner } from "@fungi.computer/watchdog";
 import { type WorkflowArmer, type WorkflowInstallationAuthority, type WorkflowTriggerPrincipal, type WorkflowTriggerTarget, type createTeamWorkflowTriggers } from "./trigger-owner.js";
+/** Installation-scoped keyset read; the default and ceiling bound one reply. */
+export declare const workflowScheduleListInputSchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodNumber>;
+    after: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type WorkflowScheduleListInput = z.input<typeof workflowScheduleListInputSchema>;
 /** Team-owned schedule records; Almanac alone decides occurrences and transitions. */
 export declare function createWorkflowSchedules(options: {
     sql: WatchdogSqliteOwner["sql"];
@@ -22,15 +29,39 @@ export declare function createWorkflowSchedules(options: {
         kind: "armed";
         scheduleId: string;
     }>;
-    list(principal: WorkflowTriggerPrincipal, installationId: string): Promise<{
-        scheduleId: string;
-        installationId: string;
-        workflowId: string;
-        triggerId: string;
-        nextDueAt: number;
-        state: "active" | "finished" | "paused" | "cancelled";
-        lastError: string | null;
-    }[]>;
+    list(principal: WorkflowTriggerPrincipal, installationId: string, input: WorkflowScheduleListInput): Promise<{
+        schedules: {
+            scheduleId: string;
+            installationId: string;
+            workflowId: string;
+            triggerId: string;
+            cron: {
+                expression: string;
+                timeZone: string;
+            };
+            nextDueAt: number;
+            state: "active" | "finished" | "paused" | "cancelled";
+            lastError: string | null;
+        }[];
+        nextCursor: string | null;
+    }>;
+    /** Pause future admission only; accepted runs and the compiled plan remain owned. */
+    pause(principal: WorkflowTriggerPrincipal, installationId: string, scheduleId: string): Promise<{
+        kind: "not_found";
+    } | {
+        kind: "paused";
+    }>;
+    /** Resume from the next occurrence; Almanac owns missed-run and retry semantics. */
+    resume(principal: WorkflowTriggerPrincipal, installationId: string, scheduleId: string): Promise<{
+        kind: "not_found";
+        reason?: never;
+    } | {
+        kind: "refused";
+        reason: string;
+    } | {
+        kind: "resumed";
+        reason?: never;
+    }>;
     disarm(principal: WorkflowTriggerPrincipal, installationId: string, scheduleId: string): Promise<{
         kind: "not_found";
     } | {

package/dist/runtime/schedules.js

@@ -1,9 +1,14 @@
-import { z } from "zod";
+import * as z from "zod";
 import * as Result from "effect/Result";
-import { afterAdmitted, afterRefused, isDue, nextOccurrence, occurrenceKey, paused, cancelled, } from "@fungi.computer/almanac";
+import { afterAdmitted, afterRefused, isDue, nextOccurrence, occurrenceKey, paused, resumed, cancelled, } from "@fungi.computer/almanac";
 import { canonicalJson, contentDigest } from "../index.js";
 import { armedWorkflowTriggerSchema, workflowArmerKey, workflowTriggerControlledBy, workflowTriggerPrincipalMember, } from "./trigger-owner.js";
 import { storedTriggerRows } from "./stored-trigger-rows.js";
+/** Installation-scoped keyset read; the default and ceiling bound one reply. */
+export const workflowScheduleListInputSchema = z.strictObject({
+    limit: z.number().int().min(1).max(100).default(50),
+    after: z.string().min(1).max(256).optional(),
+});
 const recordSchema = armedWorkflowTriggerSchema.extend({
     id: z.string().min(1).max(256),
     cron: z.strictObject({
@@ -26,7 +31,7 @@ export function createWorkflowSchedules(options) {
         key: "scheduleId",
         record: recordSchema,
     });
-    const records = () => rows.all().map((record) => {
+    const refresh = (record) => {
         if (record.state !== "active")
             return record;
         const reason = options.triggers.refusal(bindingOf(record));
@@ -35,7 +40,8 @@ export function createWorkflowSchedules(options) {
         const next = { ...paused(record), lastError: reason, retryAt: null };
         store(next);
         return next;
-    });
+    };
+    const records = () => rows.all().map(refresh);
     const nextWake = () => {
         const due = records()
             .filter((record) => record.state === "active")
@@ -89,19 +95,56 @@ export function createWorkflowSchedules(options) {
             await options.wake(nextWake());
             return { kind: "armed", scheduleId: id };
         },
-        async list(principal, installationId) {
+        async list(principal, installationId, input) {
+            await options.authorize(workflowTriggerPrincipalMember(principal), installationId);
+            const page = workflowScheduleListInputSchema.parse(input);
+            const selected = rows.installationPage(installationId, page.after ?? "", page.limit + 1);
+            const visible = selected.slice(0, page.limit).map(refresh);
+            return {
+                schedules: visible.map((record) => ({
+                    scheduleId: record.id,
+                    installationId: record.installationId,
+                    workflowId: record.workflowId,
+                    triggerId: record.triggerId,
+                    cron: record.cron,
+                    nextDueAt: record.nextDueAt,
+                    state: record.state,
+                    lastError: record.lastError,
+                })),
+                nextCursor: selected.length > page.limit ? (visible.at(-1)?.id ?? null) : null,
+            };
+        },
+        /** Pause future admission only; accepted runs and the compiled plan remain owned. */
+        async pause(principal, installationId, scheduleId) {
             await options.authorize(workflowTriggerPrincipalMember(principal), installationId);
-            return records()
-                .filter((record) => record.installationId === installationId)
-                .map((record) => ({
-                scheduleId: record.id,
-                installationId: record.installationId,
-                workflowId: record.workflowId,
-                triggerId: record.triggerId,
-                nextDueAt: record.nextDueAt,
-                state: record.state,
-                lastError: record.lastError,
-            }));
+            const record = rows.read(scheduleId);
+            if (record?.installationId !== installationId ||
+                !workflowTriggerControlledBy(principal, record) ||
+                record.state === "cancelled" ||
+                record.state === "finished")
+                return { kind: "not_found" };
+            await options.commit(() => {
+                store({ ...paused(record), retryAt: null });
+            });
+            await options.wake(nextWake());
+            return { kind: "paused" };
+        },
+        /** Resume from the next occurrence; Almanac owns missed-run and retry semantics. */
+        async resume(principal, installationId, scheduleId) {
+            await options.authorize(workflowTriggerPrincipalMember(principal), installationId);
+            const record = rows.read(scheduleId);
+            if (record?.installationId !== installationId ||
+                !workflowTriggerControlledBy(principal, record) ||
+                record.state !== "paused")
+                return { kind: "not_found" };
+            const next = resumed(record, options.now());
+            if (Result.isFailure(next))
+                return { kind: "refused", reason: next.failure.message };
+            await options.commit(() => {
+                store({ ...next.success, retryAt: null });
+            });
+            await options.wake(nextWake());
+            return { kind: "resumed" };
         },
         async disarm(principal, installationId, scheduleId) {
             const memberId = workflowTriggerPrincipalMember(principal);
@@ -130,6 +173,10 @@ export function createWorkflowSchedules(options) {
                     const result = await options.triggers.fire(binding, `${options.teamId()}/schedule/${record.id}`, {
                         scheduledAt: new Date(record.nextDueAt).toISOString(),
                         eventId: occurrenceKey(record),
+                    }, {
+                        // The existing run owner checks this in its durable-start
+                        // transaction, after authority I/O and before accepting work.
+                        admitBinding: () => JSON.stringify(rows.read(record.id)) === JSON.stringify(record),
                     });
                     next =
                         result.kind === "refused"
@@ -141,7 +188,7 @@ export function createWorkflowSchedules(options) {
                     const refused = afterRefused(record, options.now(), "Workflow execution temporarily unavailable");
                     next = { ...refused.schedule, retryAt: refused.retryAt };
                 }
-                // A disarm or re-arm admitted during upstream I/O wins over this firing.
+                // A pause, disarm or re-arm during upstream I/O wins over this firing.
                 sql.exec("UPDATE hub_workflow_schedules SET record=? WHERE scheduleId=? AND record=?", JSON.stringify(recordSchema.parse(next)), record.id, JSON.stringify(record));
             }
             await options.wake(nextWake());

package/dist/runtime/stored-trigger-rows.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod";
 import type { WatchdogSqliteOwner } from "@fungi.computer/watchdog";
 /** Stored trigger rows decode strictly; an undecodable row is corruption. */
 export declare function storedTriggerRows<Record extends z.ZodType>(sql: WatchdogSqliteOwner["sql"], table: Readonly<{
@@ -7,6 +7,8 @@ export declare function storedTriggerRows<Record extends z.ZodType>(sql: Watchdo
     record: Record;
 }>): {
     all: () => z.core.output<Record>[];
+    /** Filter and bound in SQLite, before decoding records into the owner. */
+    installationPage(installationId: string, after: string, limit: number): z.core.output<Record>[];
     read(id: string): z.core.output<Record> | null;
     remove(id: string): void;
 };

package/dist/runtime/stored-trigger-rows.js

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod";
 const rowSchema = z.strictObject({ id: z.string(), record: z.string() });
 /** Stored trigger rows decode strictly; an undecodable row is corruption. */
 export function storedTriggerRows(sql, table) {
@@ -6,6 +6,13 @@ export function storedTriggerRows(sql, table) {
     const decode = (raw) => table.record.parse(JSON.parse(rowSchema.parse(raw).record));
     return {
         all: () => sql.exec(`${select} ORDER BY ${table.key}`).toArray().map(decode),
+        /** Filter and bound in SQLite, before decoding records into the owner. */
+        installationPage(installationId, after, limit) {
+            return sql
+                .exec(`${select} WHERE json_extract(record, '$.installationId')=? AND ${table.key}>? ORDER BY ${table.key} LIMIT ?`, installationId, after, limit)
+                .toArray()
+                .map(decode);
+        },
         read(id) {
             const row = sql.exec(`${select} WHERE ${table.key}=?`, id).toArray()[0];
             return row === undefined ? null : decode(row);

package/dist/runtime/trigger-owner.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod";
 import * as S from "effect/Schema";
 import { type GitBinding, type RepositoryRef } from "@fungi.computer/agar/git";
 import { type TriggerEvent } from "../index.js";

package/dist/runtime/trigger-owner.js

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod";
 import { bindingsSelectionSchema, gitAccessScope, resolveGitAccess, } from "../git-access.js";
 import * as S from "effect/Schema";
 import { appIdSchema, releaseIdSchema, sha256DigestSchema, } from "@fungi.computer/puffball/effect";

package/dist/runtime/trigger-plans.js

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod";
 import * as S from "effect/Schema";
 import { canonicalJson, executionPlanSchema, } from "../index.js";
 import { armedWorkflowTriggerSchema, } from "./trigger-owner.js";

package/dist/runtime/trigger-router.js

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod";
 import { canonicalJson, contentDigest } from "../index.js";
 import { appEventFactSchema, } from "@fungi.computer/puffball/app-event-facts";
 import { armedWorkflowTriggerSchema, workflowArmerKey, workflowTriggerControlledBy, workflowTriggerPrincipalMember, } from "./trigger-owner.js";

package/dist/runtime/trigger-run-reservations.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod";
 import type { WatchdogSqliteOwner } from "@fungi.computer/watchdog";
 declare const triggerRunScopeSchema: z.ZodLazy<z.ZodObject<{
     installationId: z.ZodString;

package/dist/runtime/trigger-run-reservations.js

@@ -1,5 +1,5 @@
 import { defineIdFamily } from "@fungi.computer/cairn/id";
-import { z } from "zod";
+import * as z from "zod";
 import { gitSha1Schema } from "@fungi.computer/puffball/git-representation";
 import { workflowIdSchema } from "../index.js";
 const reservationIds = defineIdFamily({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fungi.computer/braid",
-  "version": "0.2.4",
+  "version": "0.4.0",
   "author": "Levi <levi@technomancy.dev>",
   "type": "module",
   "description": "Pure versioned Workflow graph validation and content-addressed compilation",
@@ -30,15 +30,15 @@
   "dependencies": {
     "@cfworker/json-schema": "4.1.1",
     "@fungi.computer/almanac": "0.2.0",
-    "@fungi.computer/mycelium": "0.2.3",
+    "@fungi.computer/mycelium": "0.3.1",
     "effect": "4.0.2",
     "jsonpointer": "5.0.1",
     "mustache": "4.2.0",
     "zod": "4.4.3",
-    "@fungi.computer/agar": "0.5.0",
+    "@fungi.computer/agar": "0.6.1",
     "@fungi.computer/gills": "0.2.0",
     "@fungi.computer/watchdog": "0.1.0",
-    "@fungi.computer/puffball": "0.2.0",
+    "@fungi.computer/puffball": "0.4.0",
     "@fungi.computer/cairn": "0.1.0"
   },
   "devDependencies": {