@treeseed/sdk 0.10.28 → 0.12.4

package/dist/operations/services/managed-repositories.js

@@ -0,0 +1,177 @@
+import { existsSync, readFileSync } from "node:fs";
+import { basename, relative, resolve } from "node:path";
+import { parse as parseYaml } from "yaml";
+import { currentBranch, gitStatusPorcelain, originRemoteUrl, repoRoot } from "./workspace-save.js";
+import { hasCompleteTreeseedPackageCheckout, sortWorkspacePackages, workspacePackages } from "./workspace-tools.js";
+import { discoverTreeseedPackageAdapters } from "./package-adapters.js";
+function readJsonFile(filePath) {
+  try {
+    return JSON.parse(readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function readStructuredFile(filePath) {
+  try {
+    const source = readFileSync(filePath, "utf8");
+    return filePath.endsWith(".yaml") || filePath.endsWith(".yml") ? parseYaml(source) : JSON.parse(source);
+  } catch {
+    return null;
+  }
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function parseGitmodulesPaths(root) {
+  const gitmodulesPath = resolve(root, ".gitmodules");
+  if (!existsSync(gitmodulesPath)) return [];
+  const source = readFileSync(gitmodulesPath, "utf8");
+  return [...source.matchAll(/^\s*path\s*=\s*(.+?)\s*$/gmu)].map((match) => match[1].replaceAll("\\", "/").trim()).filter(Boolean);
+}
+function isIndependentGitRepo(repoDir) {
+  try {
+    return resolve(repoRoot(repoDir)) === resolve(repoDir);
+  } catch {
+    return false;
+  }
+}
+function branchName(repoDir) {
+  return currentBranch(repoDir) || null;
+}
+function hasOriginRemote(repoDir) {
+  try {
+    originRemoteUrl(repoDir);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function remoteUrl(repoDir) {
+  try {
+    return originRemoteUrl(repoDir);
+  } catch {
+    return null;
+  }
+}
+function templateManifestPath(repoDir) {
+  for (const name of ["treeseed.template.yaml", "treeseed.template.yml", "treeseed.template.json"]) {
+    const candidate = resolve(repoDir, name);
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+function defaultTemplateConfigPath(repoDir) {
+  const candidate = resolve(repoDir, "template.config.json");
+  return existsSync(candidate) ? candidate : null;
+}
+function templateVersion(repoDir, manifest, config) {
+  const versionSource = stringValue(manifest?.versionSource) ?? "template.config.json";
+  const configured = stringValue(manifest?.version) ?? stringValue(config?.templateVersion);
+  if (configured) return { version: configured, versionSource };
+  const sourcePath = resolve(repoDir, versionSource);
+  const source = readJsonFile(sourcePath);
+  return {
+    version: stringValue(source?.templateVersion) ?? stringValue(source?.version),
+    versionSource
+  };
+}
+function readTreeseedTemplateRepositoryManifest(repoDir) {
+  const manifestPath = templateManifestPath(repoDir);
+  const configPath = defaultTemplateConfigPath(repoDir);
+  const manifest = manifestPath ? readStructuredFile(manifestPath) : null;
+  const config = configPath ? readStructuredFile(configPath) : null;
+  if (!manifest && !config) return null;
+  const id = stringValue(manifest?.id) ?? stringValue(config?.id) ?? basename(repoDir);
+  const release = manifest?.release && typeof manifest.release === "object" && !Array.isArray(manifest.release) ? manifest.release : {};
+  const verify = manifest?.verify && typeof manifest.verify === "object" && !Array.isArray(manifest.verify) ? manifest.verify : {};
+  const version = templateVersion(repoDir, manifest, config);
+  return {
+    id,
+    name: stringValue(manifest?.name) ?? stringValue(config?.displayName) ?? id,
+    category: stringValue(manifest?.category) ?? stringValue(config?.category) ?? "starter",
+    repository: stringValue(manifest?.repository) ?? remoteUrl(repoDir),
+    version: version.version,
+    versionSource: version.versionSource,
+    manifestPath: manifestPath ?? configPath,
+    verify: {
+      fast: stringValue(verify.fast),
+      local: stringValue(verify.local) ?? stringValue(config?.testing?.buildCommand),
+      release: stringValue(verify.release) ?? stringValue(verify.local) ?? stringValue(config?.testing?.buildCommand)
+    },
+    release: {
+      tagPrefix: stringValue(release.tagPrefix) ?? "template/",
+      recordPath: stringValue(release.recordPath) ?? `.treeseed/templates/${id}/latest-release.json`
+    }
+  };
+}
+function classifyManagedRepo(root, relativeDir, repoDir) {
+  if (relativeDir === ".") return "root";
+  if (/^starters\/[^/]+$/u.test(relativeDir) || readTreeseedTemplateRepositoryManifest(repoDir)) return "template";
+  if (/(^|\/)\.fixtures\/treeseed-fixtures$/u.test(relativeDir)) return "fixture";
+  if (/^packages\/[^/]+$/u.test(relativeDir)) return "package";
+  return "project";
+}
+function addRecursiveSubmodules(root, relativeDir, repoDir, repos) {
+  for (const submodulePath of parseGitmodulesPaths(repoDir)) {
+    const childDir = resolve(repoDir, submodulePath);
+    const childRelativeDir = relative(root, childDir).replaceAll("\\", "/") || ".";
+    if (!existsSync(childDir) || !isIndependentGitRepo(childDir)) continue;
+    if (!repos.has(childRelativeDir)) {
+      repos.set(childRelativeDir, childDir);
+    }
+    addRecursiveSubmodules(root, childRelativeDir, childDir, repos);
+  }
+}
+function discoverTreeseedManagedRepositories(root) {
+  const gitRoot = repoRoot(root);
+  const repos = /* @__PURE__ */ new Map();
+  repos.set(".", gitRoot);
+  if (hasCompleteTreeseedPackageCheckout(root)) {
+    for (const pkg of workspacePackages(root).filter((pkg2) => pkg2.name?.startsWith("@treeseed/"))) {
+      if (existsSync(resolve(pkg.dir, ".git")) && isIndependentGitRepo(pkg.dir)) {
+        repos.set(pkg.relativeDir, pkg.dir);
+      }
+    }
+  }
+  for (const adapter of discoverTreeseedPackageAdapters(root)) {
+    if (existsSync(resolve(adapter.dir, ".git")) && isIndependentGitRepo(adapter.dir)) {
+      repos.set(adapter.relativeDir, adapter.dir);
+    }
+  }
+  addRecursiveSubmodules(root, ".", gitRoot, repos);
+  return [...repos.entries()].map(([relativeDir, dir]) => {
+    const kind = classifyManagedRepo(root, relativeDir, dir);
+    const templateManifest = kind === "template" ? readTreeseedTemplateRepositoryManifest(dir) : null;
+    const name = kind === "root" ? "@treeseed/market" : kind === "template" ? `template:${templateManifest?.id ?? basename(dir)}` : kind === "fixture" ? `fixture:${relativeDir}` : readJsonFile(resolve(dir, "package.json"))?.name ?? basename(dir);
+    const branch = branchName(dir);
+    return {
+      id: relativeDir,
+      name,
+      kind,
+      dir,
+      relativeDir,
+      branchName: branch,
+      dirty: gitStatusPorcelain(dir).length > 0,
+      detached: branch == null,
+      hasOriginRemote: hasOriginRemote(dir),
+      remoteUrl: remoteUrl(dir),
+      templateManifest
+    };
+  }).sort((left, right) => sortWorkspacePackages([
+    { name: left.name, dir: left.dir, relativeDir: left.relativeDir, packageJson: {} },
+    { name: right.name, dir: right.dir, relativeDir: right.relativeDir, packageJson: {} }
+  ])[0]?.name === left.name ? -1 : 1);
+}
+function checkedOutManagedWorkflowRepos(root) {
+  return discoverTreeseedManagedRepositories(root).filter((repo) => repo.kind !== "root");
+}
+function checkedOutTemplateRepositories(root) {
+  return discoverTreeseedManagedRepositories(root).filter((repo) => repo.kind === "template" && repo.templateManifest);
+}
+export {
+  checkedOutManagedWorkflowRepos,
+  checkedOutTemplateRepositories,
+  discoverTreeseedManagedRepositories,
+  parseGitmodulesPaths,
+  readTreeseedTemplateRepositoryManifest
+};

package/dist/operations/services/operations-runner-smoke.d.ts

@@ -0,0 +1,31 @@
+export type TreeseedOperationsRunnerSmokeEnvironment = 'local' | 'staging' | 'prod';
+export interface TreeseedOperationsRunnerSmokeReport {
+    environment: TreeseedOperationsRunnerSmokeEnvironment;
+    ok: boolean;
+    baseUrl: string;
+    operationId?: string;
+    finalStatus?: string;
+    runnerId?: string | null;
+    timings: Array<{
+        phase: string;
+        durationMs: number;
+    }>;
+    events: Array<{
+        kind: string;
+        createdAt: string;
+    }>;
+    issues: string[];
+    remediation?: string;
+}
+export interface TreeseedOperationsRunnerSmokeOptions {
+    tenantRoot: string;
+    environment: TreeseedOperationsRunnerSmokeEnvironment;
+    baseUrl?: string | null;
+    serviceId?: string | null;
+    serviceSecret?: string | null;
+    timeoutMs?: number;
+    pollMs?: number;
+    fetchImpl?: typeof fetch;
+    env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
+}
+export declare function runTreeseedOperationsRunnerSmoke(options: TreeseedOperationsRunnerSmokeOptions): Promise<TreeseedOperationsRunnerSmokeReport>;

package/dist/operations/services/operations-runner-smoke.js

@@ -0,0 +1,198 @@
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { loadTreeseedDeployConfigFromPath } from "../../platform/deploy-config.js";
+import { resolveTreeseedMachineEnvironmentValues } from "./config-runtime.js";
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+function normalizedBaseUrl(value2) {
+  return value2.trim().replace(/\/+$/u, "");
+}
+function value(name, values, env) {
+  const candidate = env[name] ?? values[name];
+  return typeof candidate === "string" && candidate.trim() ? candidate.trim() : null;
+}
+function envValue(name, env) {
+  const candidate = env[name];
+  return typeof candidate === "string" && candidate.trim() ? candidate.trim() : null;
+}
+function manifestApiBaseUrl(tenantRoot, environment) {
+  const candidates = [
+    resolve(tenantRoot, "treeseed.site.yaml"),
+    resolve(tenantRoot, "..", "..", "treeseed.site.yaml")
+  ];
+  for (const candidate of candidates) {
+    if (!existsSync(candidate)) continue;
+    try {
+      const config = loadTreeseedDeployConfigFromPath(candidate);
+      const connectionUrl = config.connections?.api?.environments?.[environment]?.baseUrl;
+      const serviceUrl = config.services?.api?.environments?.[environment]?.baseUrl;
+      const baseUrl = connectionUrl ?? serviceUrl;
+      if (typeof baseUrl === "string" && baseUrl.trim()) {
+        return baseUrl.trim();
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function defaultBaseUrl(environment) {
+  if (environment === "local") return "http://127.0.0.1:3000";
+  return environment === "prod" ? "https://api.treeseed.dev" : "https://api.preview.treeseed.dev";
+}
+function localManagedDevServiceSecret(environment) {
+  return environment === "local" ? "treeseed-web-service-dev-secret" : null;
+}
+async function timed(timings, phase, action) {
+  const started = Date.now();
+  try {
+    return await action();
+  } finally {
+    timings.push({ phase, durationMs: Date.now() - started });
+  }
+}
+async function requestJson(fetchImpl, url, options = {}) {
+  const response = await fetchImpl(url, {
+    ...options,
+    headers: {
+      accept: "application/json",
+      ...options.body ? { "content-type": "application/json" } : {},
+      ...options.headers ?? {}
+    }
+  });
+  const text = await response.text();
+  const payload = text ? JSON.parse(text) : {};
+  if (!response.ok) {
+    const message = typeof payload?.error === "string" ? payload.error : typeof payload?.error?.message === "string" ? payload.error.message : typeof payload?.message === "string" ? payload.message : `HTTP ${response.status}`;
+    throw new Error(`${options.method ?? "GET"} ${url} failed: ${message}`);
+  }
+  return payload;
+}
+function operationFrom(payload) {
+  return payload?.operation ?? payload?.payload?.operation ?? null;
+}
+function eventsFrom(payload) {
+  const events = Array.isArray(payload?.events) ? payload.events : Array.isArray(payload?.payload?.events) ? payload.payload.events : [];
+  return events.map((event) => ({
+    kind: String(event?.kind ?? "unknown"),
+    createdAt: String(event?.createdAt ?? event?.created_at ?? "")
+  }));
+}
+function isSuccessfulOperationStatus(status) {
+  return ["completed", "succeeded"].includes(String(status ?? "").toLowerCase());
+}
+function remediationFor(environment) {
+  if (environment === "local") {
+    return "Verify managed local dev is running with `npx trsd dev start --web-runtime local --json`, then check API and runner readiness with `npx trsd dev status --json`.";
+  }
+  return "Verify the API service, Treeseed database, and operationsRunner Railway service, then run `npx trsd hosting verify --service operationsRunner --live --json`.";
+}
+function failure(baseUrl, environment, issues, timings, extra = {}) {
+  return {
+    environment,
+    ok: false,
+    baseUrl,
+    timings,
+    events: [],
+    issues,
+    remediation: remediationFor(environment),
+    ...extra
+  };
+}
+async function runTreeseedOperationsRunnerSmoke(options) {
+  const env = options.env ?? process.env;
+  let values = {};
+  try {
+    values = resolveTreeseedMachineEnvironmentValues(options.tenantRoot, options.environment);
+  } catch {
+    values = {};
+  }
+  const baseUrl = normalizedBaseUrl(
+    options.baseUrl ?? manifestApiBaseUrl(options.tenantRoot, options.environment) ?? value("TREESEED_API_BASE_URL", values, env) ?? value("TREESEED_CENTRAL_MARKET_API_BASE_URL", values, env) ?? defaultBaseUrl(options.environment)
+  );
+  const serviceId = options.serviceId ?? value("TREESEED_ACCEPTANCE_SERVICE_ID", values, env) ?? value("TREESEED_WEB_SERVICE_ID", values, env) ?? value("TREESEED_API_WEB_SERVICE_ID", values, env) ?? "web";
+  const localServiceSecret = options.environment === "local" ? envValue("TREESEED_ACCEPTANCE_SERVICE_SECRET", env) ?? envValue("TREESEED_WEB_SERVICE_SECRET", env) ?? envValue("TREESEED_API_WEB_SERVICE_SECRET", env) ?? localManagedDevServiceSecret(options.environment) : null;
+  const serviceSecret = options.serviceSecret ?? localServiceSecret ?? value("TREESEED_ACCEPTANCE_SERVICE_SECRET", values, env) ?? value("TREESEED_WEB_SERVICE_SECRET", values, env) ?? value("TREESEED_API_WEB_SERVICE_SECRET", values, env);
+  const timings = [];
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const timeoutMs = Math.max(1e3, Math.floor(options.timeoutMs ?? (options.environment === "prod" ? 12e4 : 9e4)));
+  const pollMs = Math.max(1e3, Math.floor(options.pollMs ?? 3e3));
+  if (!serviceSecret) {
+    return failure(baseUrl, options.environment, ["Missing API service credential for runner smoke."], timings);
+  }
+  const headers = {
+    "x-treeseed-service-id": serviceId,
+    "x-treeseed-service-secret": serviceSecret
+  };
+  try {
+    await timed(timings, "healthz", () => requestJson(fetchImpl, `${baseUrl}/healthz`));
+    await timed(timings, "healthz-deep", () => requestJson(fetchImpl, `${baseUrl}/healthz/deep`));
+    const idempotencyKey = `smoke:${options.environment}:${Date.now()}`;
+    const created = await timed(timings, "operation-create", () => requestJson(fetchImpl, `${baseUrl}/v1/platform/operations`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        namespace: "market",
+        operation: "diagnostic",
+        target: "market_operations_runner",
+        idempotencyKey,
+        input: {
+          source: "trsd.operations.smoke",
+          environment: options.environment
+        }
+      })
+    }));
+    const operation = operationFrom(created);
+    const operationId = typeof operation?.id === "string" ? operation.id : null;
+    if (!operationId) {
+      return failure(baseUrl, options.environment, ["API did not return a diagnostic operation id."], timings);
+    }
+    const deadline = Date.now() + timeoutMs;
+    let current = operation;
+    while (Date.now() < deadline) {
+      current = operationFrom(await timed(timings, "operation-poll", () => requestJson(fetchImpl, `${baseUrl}/v1/platform/operations/${encodeURIComponent(operationId)}`, { headers }))) ?? current;
+      if (isSuccessfulOperationStatus(current?.status)) {
+        const eventPayload = await timed(timings, "operation-events", () => requestJson(fetchImpl, `${baseUrl}/v1/platform/operations/${encodeURIComponent(operationId)}/events`, { headers }));
+        const events = eventsFrom(eventPayload);
+        const sawRunnerEvent = events.some((event) => /checkpoint|complete|runner|market\.noop/iu.test(event.kind));
+        if (!sawRunnerEvent) {
+          return failure(baseUrl, options.environment, ["Diagnostic operation completed but no runner checkpoint/completion event was recorded."], timings, {
+            operationId,
+            finalStatus: String(current?.status ?? "completed"),
+            runnerId: current?.assignedRunnerId ?? null,
+            events
+          });
+        }
+        return {
+          environment: options.environment,
+          ok: true,
+          baseUrl,
+          operationId,
+          finalStatus: String(current?.status ?? "completed"),
+          runnerId: current?.assignedRunnerId ?? null,
+          timings,
+          events,
+          issues: []
+        };
+      }
+      if (["failed", "cancelled", "timed_out"].includes(String(current?.status ?? ""))) {
+        return failure(baseUrl, options.environment, [`Diagnostic operation ended with status ${current.status}.`], timings, {
+          operationId,
+          finalStatus: current.status,
+          runnerId: current?.assignedRunnerId ?? null
+        });
+      }
+      await sleep(pollMs);
+    }
+    return failure(baseUrl, options.environment, [`Diagnostic operation was not completed within ${timeoutMs}ms.`], timings, {
+      operationId,
+      finalStatus: current?.status ?? "unknown",
+      runnerId: current?.assignedRunnerId ?? null
+    });
+  } catch (error) {
+    return failure(baseUrl, options.environment, [error instanceof Error ? error.message : String(error)], timings);
+  }
+}
+export {
+  runTreeseedOperationsRunnerSmoke
+};

package/dist/operations/services/package-adapters.d.ts

@@ -0,0 +1,170 @@
+import type { SeedProjectResource } from '../../seeds/types.js';
+export type TreeseedPackageKind = 'node-typescript' | 'beam-elixir-rust';
+export type TreeseedPackageCommand = {
+    label: string;
+    command: string;
+    args: string[];
+    cwd: string;
+};
+export type TreeseedPackageAdapter = {
+    id: string;
+    name: string;
+    kind: TreeseedPackageKind;
+    dir: string;
+    relativeDir: string;
+    version: string | null;
+    publishTarget: string | null;
+    manifestPath: string | null;
+    versionSource: string | null;
+    verifyCommands: {
+        fast: TreeseedPackageCommand | null;
+        local: TreeseedPackageCommand | null;
+        release: TreeseedPackageCommand | null;
+    };
+    artifacts: Array<{
+        provider: 'npm' | 'docker';
+        name: string;
+        tags?: string[];
+        dockerfile?: string | null;
+        context?: string | null;
+        target?: string | null;
+        role?: string | null;
+        architectures?: string[];
+    }>;
+    releaseChecks: Array<{
+        kind: 'npm-pack-dry-run' | 'github-workflow' | 'docker-manifest';
+        name: string;
+        detail: string;
+    }>;
+    metadata: Record<string, unknown>;
+};
+export type TreeseedPackageManifestValidation = {
+    packageId: string;
+    path: string;
+    manifestPath: string | null;
+    ok: boolean;
+    errors: string[];
+    warnings: string[];
+};
+export type TreeseedPackageDevelopmentImagePlan = {
+    package: {
+        id: string;
+        name: string;
+        path: string;
+        kind: TreeseedPackageKind;
+        version: string | null;
+        publishTarget: string | null;
+        metadata: Record<string, unknown>;
+    };
+    repository: string;
+    workflow: string;
+    branch: string;
+    refs: {
+        imageName: string;
+        branch: string;
+        branchSlug: string;
+        sha: string;
+        shortSha: string;
+        immutableTag: string | null;
+        movingTag: string | null;
+        imageRef: string | null;
+        movingImageRef: string | null;
+        archImageRefs: string[];
+        roleImages?: Array<{
+            role: string;
+            imageName: string;
+            target: string | null;
+            immutableRef: string | null;
+            movingRef: string | null;
+            archImageRefs: string[];
+        }>;
+    };
+    hosting: {
+        app: string;
+        environment: string;
+        overrideEnvVar: string;
+        override: Record<string, string>;
+        command: string;
+    } | null;
+    deploymentSource: {
+        environment: string;
+        mode: 'git' | 'image';
+        repository: string;
+        commitSha: string;
+        imagePublicationRequired: boolean;
+    };
+};
+export type TreeseedPackageImageWorkflowOptions = {
+    root?: string;
+    packageId: string;
+    branch?: string | null;
+    workflow?: string | null;
+    execute?: boolean;
+    syncConfig?: boolean;
+    env?: NodeJS.ProcessEnv;
+};
+export type TreeseedPackageWorkflowTemplateKind = 'npm-publish' | 'docker-image' | 'release-gate';
+export type TreeseedPackageWorkflowSyncResult = {
+    packageId: string;
+    path: string;
+    workflow: string;
+    template: TreeseedPackageWorkflowTemplateKind;
+    exists: boolean;
+    changed: boolean;
+    written: boolean;
+};
+export declare function readMixProjectVersion(filePath: string): string | null;
+export declare function planTreeseedPackageDevelopmentImage(root: any, idOrName: string, { branch }?: {
+    branch?: string | null;
+}): TreeseedPackageDevelopmentImagePlan;
+export declare function discoverTreeseedPackageAdapters(root?: any): TreeseedPackageAdapter[];
+export declare function findTreeseedPackageAdapter(root: string, idOrName: string): TreeseedPackageAdapter | null;
+export declare function packageAdapterPlanSummary(root?: any): {
+    id: string;
+    name: string;
+    kind: TreeseedPackageKind;
+    path: string;
+    version: string | null;
+    publishTarget: string | null;
+    verify: {
+        [k: string]: string | null;
+    };
+    artifacts: {
+        provider: "npm" | "docker";
+        name: string;
+        tags?: string[];
+        dockerfile?: string | null;
+        context?: string | null;
+        target?: string | null;
+        role?: string | null;
+        architectures?: string[];
+    }[];
+    releaseChecks: {
+        kind: "npm-pack-dry-run" | "github-workflow" | "docker-manifest";
+        name: string;
+        detail: string;
+    }[];
+    metadata: Record<string, unknown>;
+}[];
+export declare function runTreeseedPackageImageWorkflow(options: TreeseedPackageImageWorkflowOptions): Promise<{
+    imagePlan: TreeseedPackageDevelopmentImagePlan;
+    selectedWorkflow: string;
+    dockerHub: {
+        usernameConfigured: boolean;
+        tokenConfigured: boolean;
+        requiredSecrets: string[];
+        requiredVariables: string[];
+    };
+    credential: import("./github-credentials.js").TreeseedGitHubCredentialResolution;
+    report: Record<string, unknown>;
+}>;
+export declare function validateTreeseedPackageManifests(root?: any): TreeseedPackageManifestValidation[];
+export declare function deriveTreeseedPackageProjectResources(root?: any, options?: {
+    team?: string;
+}): SeedProjectResource[];
+export declare function renderTreeseedPackageWorkflow(adapter: TreeseedPackageAdapter, template: TreeseedPackageWorkflowTemplateKind): string;
+export declare function syncTreeseedPackageWorkflows({ root, packageId, execute, }?: {
+    root?: string;
+    packageId?: string | null;
+    execute?: boolean;
+}): TreeseedPackageWorkflowSyncResult[];