@pome-sh/cli 0.21.5 → 0.21.7

package/dist/chunk-ZKID2HS3.js

@@ -0,0 +1,628 @@
+import { z, ZodError } from 'zod';
+
+// ../packages/twin-linear/dist/src/errors.js
+var LinearTwinError = class extends Error {
+  status;
+  code;
+  extensions;
+  constructor(status, code, message, extensions = {}) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.extensions = extensions;
+    this.name = "LinearTwinError";
+  }
+  toGraphQLError() {
+    return {
+      message: this.message,
+      extensions: {
+        code: this.code,
+        http: { status: this.status },
+        ...this.extensions
+      }
+    };
+  }
+};
+function unauthorizedEnvelope(message = "Authentication required") {
+  return {
+    status: 401,
+    body: {
+      errors: [
+        {
+          message,
+          extensions: { code: "AUTHENTICATION_ERROR", http: { status: 401 } }
+        }
+      ]
+    }
+  };
+}
+function unsupportedEnvelope(method, path) {
+  return {
+    status: 501,
+    body: {
+      message: `Unsupported Linear twin route: ${method} ${path}`,
+      errors: [
+        {
+          message: "Not implemented",
+          extensions: { code: "UNIMPLEMENTED", http: { status: 501 } }
+        }
+      ],
+      fidelity: "unsupported",
+      method,
+      path
+    }
+  };
+}
+function linearErrorEnvelope(error) {
+  if (error instanceof LinearTwinError) {
+    return {
+      status: error.status,
+      body: { errors: [error.toGraphQLError()] }
+    };
+  }
+  if (error instanceof ZodError || error instanceof Error && error.name === "ZodError") {
+    const message = error instanceof ZodError ? error.issues[0]?.message ?? "Invalid request" : "Invalid request";
+    return {
+      status: 400,
+      body: {
+        errors: [
+          {
+            message,
+            extensions: { code: "BAD_USER_INPUT", http: { status: 400 } }
+          }
+        ]
+      }
+    };
+  }
+  if (error instanceof SyntaxError) {
+    return {
+      status: 400,
+      body: {
+        errors: [
+          {
+            message: "Invalid JSON",
+            extensions: { code: "BAD_USER_INPUT", http: { status: 400 } }
+          }
+        ]
+      }
+    };
+  }
+  if (error instanceof Error && error.name === "UnknownToolError") {
+    return {
+      status: 404,
+      body: {
+        errors: [
+          {
+            message: error.message,
+            extensions: { code: "NOT_FOUND", http: { status: 404 } }
+          }
+        ]
+      }
+    };
+  }
+  return {
+    status: 500,
+    body: {
+      errors: [
+        {
+          message: error instanceof Error ? error.message : "Internal Server Error",
+          extensions: { code: "INTERNAL_SERVER_ERROR", http: { status: 500 } }
+        }
+      ]
+    }
+  };
+}
+function badUserInput(message, extensions = {}) {
+  throw new LinearTwinError(400, "BAD_USER_INPUT", message, extensions);
+}
+function notFound(message) {
+  throw new LinearTwinError(404, "NOT_FOUND", message);
+}
+
+// ../packages/twin-linear/dist/src/types.js
+var DEFAULT_LINEAR_CLOCK = "2026-07-21T00:00:00.000Z";
+var DEFAULT_LINEAR_EMAIL = "admin@pome-twin.test";
+var DEFAULT_LINEAR_TOKEN = "lin_test_admin";
+var LINEAR_PROVIDER_TOKEN_PREFIX = "lin_pome_";
+var DEFAULT_LINEAR_SID = "standalone";
+var DEFAULT_LINEAR_PORT = 3337;
+var DEFAULT_SCOPES = ["read", "write", "issues:create", "comments:create", "admin"];
+var TITLE_MAX_BYTES = 512;
+var BODY_MAX_BYTES = 65536;
+var GRAPHQL_QUERY_MAX_BYTES = 1e5;
+var GRAPHQL_SELECTION_DEPTH_MAX = 20;
+var MCP_PAGE_DEFAULT = 50;
+var MCP_PAGE_MAX = 250;
+var RELAY_PAGE_DEFAULT = 50;
+var RELAY_PAGE_MAX = 250;
+var STATE_EXPORT_CAP = 2e3;
+var OAUTH_CODE_TTL_SECONDS = 600;
+var ACCESS_TOKEN_TTL_SECONDS = 3600;
+
+// ../packages/twin-linear/dist/src/webhook-url.js
+function webhookUrlError(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return `Invalid webhook URL: ${url}`;
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    return `Webhook URL must use http or https: ${url}`;
+  }
+  if (parsed.username || parsed.password) {
+    return `Webhook URL must not include credentials`;
+  }
+  return null;
+}
+function assertWebhookUrl(url) {
+  const error = webhookUrlError(url);
+  if (error)
+    badUserInput(error);
+  return url;
+}
+var datetime = z.string().datetime({ offset: true });
+var email = z.string().trim().email().transform((v) => v.toLowerCase());
+var id = z.string().min(1).max(128);
+var scopesField = z.union([z.array(z.string().min(1).max(64)).max(50), z.string().max(500)]).optional();
+var stateType = z.enum(["backlog", "unstarted", "started", "completed", "canceled"]);
+var linearSeedSchema = z.object({
+  clock: datetime.default(DEFAULT_LINEAR_CLOCK),
+  defaultSid: z.string().min(1).max(128).default(DEFAULT_LINEAR_SID),
+  baseUrl: z.string().url().default("http://127.0.0.1:3337"),
+  strictScopes: z.boolean().default(false),
+  organization: z.object({
+    id: id.optional(),
+    name: z.string().min(1).max(200).optional(),
+    urlKey: z.string().min(1).max(100).optional()
+  }).strict().optional(),
+  users: z.array(z.object({
+    id: id.optional(),
+    email,
+    name: z.string().min(1).max(200).optional(),
+    displayName: z.string().min(1).max(200).optional(),
+    avatarUrl: z.string().url().nullable().optional(),
+    active: z.boolean().default(true),
+    admin: z.boolean().default(false),
+    app: z.boolean().default(false)
+  }).strict()).max(500).default([]),
+  teams: z.array(z.object({
+    id: id.optional(),
+    key: z.string().min(1).max(20).regex(/^[A-Z][A-Z0-9]*$/),
+    name: z.string().min(1).max(200),
+    description: z.string().max(2e3).nullable().optional(),
+    private: z.boolean().default(false),
+    states: z.array(z.object({
+      id: id.optional(),
+      name: z.string().min(1).max(100),
+      type: stateType.optional(),
+      position: z.number().int().nonnegative().optional()
+    }).strict()).max(50).optional()
+  }).strict()).max(50).default([]),
+  labels: z.array(z.object({
+    id: id.optional(),
+    name: z.string().min(1).max(100),
+    color: z.string().max(32).optional(),
+    description: z.string().max(2e3).nullable().optional(),
+    team: z.string().min(1).max(128).optional()
+  }).strict()).max(500).default([]),
+  projects: z.array(z.object({
+    id: id.optional(),
+    name: z.string().min(1).max(200),
+    description: z.string().max(1e4).nullable().optional(),
+    state: z.enum(["planned", "started", "completed", "canceled"]).default("planned"),
+    team: z.string().min(1).max(128).optional()
+  }).strict()).max(200).default([]),
+  cycles: z.array(z.object({
+    id: id.optional(),
+    team: z.string().min(1).max(128),
+    name: z.string().min(1).max(200),
+    number: z.number().int().positive().optional(),
+    startsAt: datetime.nullable().optional(),
+    endsAt: datetime.nullable().optional()
+  }).strict()).max(200).default([]),
+  issues: z.array(z.object({
+    id: id.optional(),
+    team: z.string().min(1).max(128),
+    title: z.string().min(1).max(512),
+    description: z.string().max(65536).nullable().optional(),
+    priority: z.union([z.literal(0), z.literal(1), z.literal(2), z.literal(3), z.literal(4)]).default(0),
+    state: z.string().min(1).max(128).optional(),
+    assignee: z.string().min(1).max(200).optional(),
+    creator: z.string().min(1).max(200).optional(),
+    delegate: z.string().min(1).max(200).optional(),
+    project: z.string().min(1).max(200).optional(),
+    cycle: z.string().min(1).max(200).optional(),
+    parent: z.string().min(1).max(200).optional(),
+    estimate: z.number().int().nonnegative().nullable().optional(),
+    labels: z.array(z.string().min(1).max(100)).max(50).default([]),
+    dueDate: z.string().max(32).nullable().optional(),
+    createdAt: datetime.optional(),
+    updatedAt: datetime.optional()
+  }).strict()).max(5e3).default([]),
+  comments: z.array(z.object({
+    id: id.optional(),
+    issue: z.string().min(1).max(128),
+    body: z.string().min(1).max(65536),
+    parent: z.string().min(1).max(128).optional(),
+    user: z.string().min(1).max(200).optional(),
+    createdAt: datetime.optional()
+  }).strict()).max(2e4).default([]),
+  documents: z.array(z.object({
+    id: id.optional(),
+    title: z.string().min(1).max(512),
+    content: z.string().max(65536).nullable().optional(),
+    slug: z.string().min(1).max(200).optional(),
+    project: z.string().min(1).max(200).optional(),
+    team: z.string().min(1).max(128).optional(),
+    issue: z.string().min(1).max(200).optional(),
+    cycle: z.string().min(1).max(200).optional(),
+    icon: z.string().max(64).nullable().optional(),
+    color: z.string().max(32).nullable().optional(),
+    creator: z.string().min(1).max(200).optional(),
+    createdAt: datetime.optional(),
+    updatedAt: datetime.optional()
+  }).strict()).max(500).default([]),
+  oauthApps: z.array(z.object({
+    id: id.optional(),
+    clientId: z.string().min(1).max(200),
+    clientSecret: z.string().min(1).max(500),
+    name: z.string().min(1).max(200),
+    redirectUris: z.array(z.string().url()).min(1).max(20),
+    scopes: scopesField,
+    actor: z.enum(["user", "app"]).default("user"),
+    assignable: z.boolean().default(false),
+    mentionable: z.boolean().default(false),
+    appUserId: z.string().min(1).max(128).nullable().optional()
+  }).strict()).max(20).default([]),
+  tokens: z.array(z.object({
+    token: z.string().min(1).max(500),
+    type: z.enum(["personal", "oauth_access", "client_credentials"]).default("personal"),
+    user: z.string().min(1).max(200).optional(),
+    app: z.string().min(1).max(200).optional(),
+    scopes: scopesField,
+    actor: z.enum(["user", "app"]).optional(),
+    sid: z.string().min(1).max(128).optional(),
+    expiresAt: datetime.nullable().optional()
+  }).strict()).max(50).default([]),
+  webhooks: z.array(z.object({
+    id: id.optional(),
+    label: z.string().min(1).max(200).optional(),
+    url: z.string().url(),
+    resourceTypes: scopesField,
+    team: z.string().min(1).max(128).optional(),
+    allPublicTeams: z.boolean().optional(),
+    secret: z.string().max(500).nullable().optional(),
+    enabled: z.boolean().default(true)
+  }).strict()).max(50).default([])
+}).strict().superRefine((seed, ctx) => {
+  const teamKeys = new Set(seed.teams.map((t) => t.key));
+  const teamIds = new Set(seed.teams.map((t) => t.id).filter(Boolean));
+  const userEmails = new Set(seed.users.map((u) => u.email));
+  const userIds = new Set(seed.users.map((u) => u.id).filter(Boolean));
+  const labelNames = new Set(seed.labels.map((l) => l.name));
+  const projectNames = new Set(seed.projects.map((p) => p.name));
+  const cycleNames = new Set(seed.cycles.map((c) => c.name));
+  const issueTitlesByTeam = /* @__PURE__ */ new Map();
+  const resolveTeam = (ref) => teamKeys.has(ref) || teamIds.has(ref);
+  const resolveUser = (ref) => userEmails.has(ref.toLowerCase()) || userIds.has(ref) || seed.users.some((u) => u.name === ref || u.displayName === ref);
+  for (const team of seed.teams) {
+    const stateNames = /* @__PURE__ */ new Set();
+    for (const state of team.states ?? []) {
+      if (stateNames.has(state.name)) {
+        ctx.addIssue({ code: "custom", message: `Duplicate workflow state ${state.name} on team ${team.key}` });
+      }
+      stateNames.add(state.name);
+    }
+  }
+  for (const label of seed.labels) {
+    if (label.team && !resolveTeam(label.team)) {
+      ctx.addIssue({ code: "custom", message: `Label team not found: ${label.team}` });
+    }
+  }
+  for (const project of seed.projects) {
+    if (project.team && !resolveTeam(project.team)) {
+      ctx.addIssue({ code: "custom", message: `Project team not found: ${project.team}` });
+    }
+  }
+  for (const cycle of seed.cycles) {
+    if (!resolveTeam(cycle.team)) {
+      ctx.addIssue({ code: "custom", message: `Cycle team not found: ${cycle.team}` });
+    }
+  }
+  for (const issue of seed.issues) {
+    if (!resolveTeam(issue.team)) {
+      ctx.addIssue({ code: "custom", message: `Issue team not found: ${issue.team}` });
+    }
+    if (issue.assignee && !resolveUser(issue.assignee)) {
+      ctx.addIssue({ code: "custom", message: `Issue assignee not found: ${issue.assignee}` });
+    }
+    if (issue.creator && !resolveUser(issue.creator)) {
+      ctx.addIssue({ code: "custom", message: `Issue creator not found: ${issue.creator}` });
+    }
+    if (issue.delegate && !resolveUser(issue.delegate)) {
+      ctx.addIssue({ code: "custom", message: `Issue delegate not found: ${issue.delegate}` });
+    }
+    if (issue.project && !projectNames.has(issue.project) && !seed.projects.some((p) => p.id === issue.project)) {
+      ctx.addIssue({ code: "custom", message: `Issue project not found: ${issue.project}` });
+    }
+    if (issue.cycle && !cycleNames.has(issue.cycle) && !seed.cycles.some((c) => c.id === issue.cycle || String(c.number) === issue.cycle)) {
+      ctx.addIssue({ code: "custom", message: `Issue cycle not found: ${issue.cycle}` });
+    }
+    for (const label of issue.labels) {
+      if (!labelNames.has(label) && !seed.labels.some((l) => l.id === label)) {
+        ctx.addIssue({ code: "custom", message: `Issue label not found: ${label}` });
+      }
+    }
+    if (issue.state) {
+      const team = seed.teams.find((t) => t.key === issue.team || t.id === issue.team);
+      const states = team?.states ?? [];
+      const defaultNames = ["Backlog", "Todo", "In Progress", "Done", "Canceled"];
+      const ok = states.some((s) => s.name === issue.state || s.id === issue.state) || defaultNames.includes(issue.state);
+      if (!ok && states.length > 0) {
+        ctx.addIssue({ code: "custom", message: `Issue state not found: ${issue.state}` });
+      }
+    }
+    const titles = issueTitlesByTeam.get(issue.team) ?? /* @__PURE__ */ new Set();
+    if (titles.has(issue.title)) {
+      ctx.addIssue({ code: "custom", message: `Duplicate issue title on team ${issue.team}: ${issue.title}` });
+    }
+    titles.add(issue.title);
+    issueTitlesByTeam.set(issue.team, titles);
+  }
+  for (const comment of seed.comments) {
+    const issueOk = seed.issues.some((i) => i.id === comment.issue || i.title === comment.issue) || /^[A-Z]+-\d+$/.test(comment.issue);
+    if (!issueOk) {
+      ctx.addIssue({ code: "custom", message: `Comment issue not found: ${comment.issue}` });
+    }
+    if (comment.user && !resolveUser(comment.user)) {
+      ctx.addIssue({ code: "custom", message: `Comment user not found: ${comment.user}` });
+    }
+  }
+  for (const app of seed.oauthApps) {
+    for (const uri of app.redirectUris) {
+      try {
+        new URL(uri);
+      } catch {
+        ctx.addIssue({ code: "custom", message: `Invalid OAuth redirect URI: ${uri}` });
+      }
+    }
+    if (app.appUserId && !resolveUser(app.appUserId)) {
+      ctx.addIssue({ code: "custom", message: `OAuth app user not found: ${app.appUserId}` });
+    }
+  }
+  for (const token of seed.tokens) {
+    if (token.user && !resolveUser(token.user)) {
+      ctx.addIssue({ code: "custom", message: `Token user not found: ${token.user}` });
+    }
+    if (token.app && !seed.oauthApps.some((a) => a.clientId === token.app || a.id === token.app)) {
+      ctx.addIssue({ code: "custom", message: `Token app not found: ${token.app}` });
+    }
+  }
+  for (const webhook of seed.webhooks) {
+    const urlError = webhookUrlError(webhook.url);
+    if (urlError) {
+      ctx.addIssue({ code: "custom", message: urlError });
+    }
+    if (webhook.team && !resolveTeam(webhook.team)) {
+      ctx.addIssue({ code: "custom", message: `Webhook team not found: ${webhook.team}` });
+    }
+  }
+});
+function parseSeed(input) {
+  return linearSeedSchema.parse(input);
+}
+function loadSeedFromEnv(env = process.env) {
+  const raw = env.POME_SEED_JSON;
+  if (!raw)
+    return parseSeed(defaultSeedState());
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`POME_SEED_JSON is not valid JSON: ${error.message}`);
+  }
+  return parseSeed(parsed);
+}
+function defaultSeedState() {
+  return {
+    clock: DEFAULT_LINEAR_CLOCK,
+    defaultSid: DEFAULT_LINEAR_SID,
+    baseUrl: "http://127.0.0.1:3337",
+    strictScopes: false,
+    organization: {
+      id: "org_pome",
+      name: "Pome Twin",
+      urlKey: "pome-twin"
+    },
+    users: [
+      {
+        id: "user_admin",
+        email: DEFAULT_LINEAR_EMAIL,
+        name: "Admin User",
+        displayName: "Admin",
+        admin: true,
+        active: true
+      },
+      {
+        id: "user_dev",
+        email: "dev@pome-twin.test",
+        name: "Developer",
+        displayName: "Dev",
+        admin: false,
+        active: true
+      },
+      {
+        id: "user_agent",
+        email: "agent@pome-twin.test",
+        name: "Pome Agent",
+        displayName: "Pome Agent",
+        admin: false,
+        active: true,
+        app: true
+      }
+    ],
+    teams: [
+      {
+        id: "team_eng",
+        key: "ENG",
+        name: "Engineering",
+        description: "Default engineering team",
+        private: false,
+        states: [
+          { id: "state_backlog", name: "Backlog", type: "backlog", position: 0 },
+          { id: "state_todo", name: "Todo", type: "unstarted", position: 1 },
+          { id: "state_progress", name: "In Progress", type: "started", position: 2 },
+          { id: "state_done", name: "Done", type: "completed", position: 3 },
+          { id: "state_canceled", name: "Canceled", type: "canceled", position: 4 }
+        ]
+      }
+    ],
+    labels: [
+      { id: "label_bug", name: "Bug", color: "#d92d20", team: "ENG", description: "Defect" },
+      { id: "label_feature", name: "Feature", color: "#2563eb", team: "ENG", description: "New work" },
+      { id: "label_agent", name: "Agent", color: "#0f766e", team: "ENG", description: "Agent triage" }
+    ],
+    projects: [
+      {
+        id: "project_local",
+        name: "Local Twin",
+        description: "Agent evaluation workspace",
+        state: "started",
+        team: "ENG"
+      }
+    ],
+    cycles: [
+      {
+        id: "cycle_1",
+        team: "ENG",
+        name: "Cycle 1",
+        number: 1,
+        startsAt: "2026-07-14T00:00:00.000Z",
+        endsAt: "2026-07-28T00:00:00.000Z"
+      }
+    ],
+    issues: [
+      {
+        id: "issue_backlog",
+        team: "ENG",
+        title: "Triage inbox for agent eval",
+        description: "Backlog item waiting for triage.",
+        priority: 2,
+        state: "Backlog",
+        assignee: "dev@pome-twin.test",
+        creator: DEFAULT_LINEAR_EMAIL,
+        project: "Local Twin",
+        cycle: "Cycle 1",
+        labels: ["Agent"],
+        createdAt: "2026-07-20T10:00:00.000Z",
+        updatedAt: "2026-07-20T10:00:00.000Z"
+      },
+      {
+        id: "issue_todo",
+        team: "ENG",
+        title: "Ship Linear twin GraphQL surface",
+        description: "Implement issue CRUD + comments for agent testing.",
+        priority: 3,
+        state: "Todo",
+        assignee: "dev@pome-twin.test",
+        creator: DEFAULT_LINEAR_EMAIL,
+        project: "Local Twin",
+        cycle: "Cycle 1",
+        labels: ["Feature"],
+        createdAt: "2026-07-20T12:00:00.000Z",
+        updatedAt: "2026-07-20T14:00:00.000Z"
+      },
+      {
+        id: "issue_progress",
+        team: "ENG",
+        title: "Wire MCP tools to commands",
+        description: "Keep GraphQL and MCP on the same LinearDomain layer.",
+        priority: 2,
+        state: "In Progress",
+        assignee: DEFAULT_LINEAR_EMAIL,
+        creator: DEFAULT_LINEAR_EMAIL,
+        project: "Local Twin",
+        cycle: "Cycle 1",
+        labels: ["Feature", "Agent"],
+        createdAt: "2026-07-20T16:00:00.000Z",
+        updatedAt: "2026-07-21T00:00:00.000Z"
+      },
+      {
+        id: "issue_done",
+        team: "ENG",
+        title: "Seed multi-issue agent world",
+        description: "Default seed covers backlog/todo/progress/done.",
+        priority: 1,
+        state: "Done",
+        assignee: "dev@pome-twin.test",
+        creator: DEFAULT_LINEAR_EMAIL,
+        project: "Local Twin",
+        labels: ["Bug"],
+        createdAt: "2026-07-19T09:00:00.000Z",
+        updatedAt: "2026-07-20T18:00:00.000Z"
+      }
+    ],
+    comments: [
+      {
+        id: "comment_1",
+        issue: "Ship Linear twin GraphQL surface",
+        body: "Starting with viewer + issues queries.",
+        user: DEFAULT_LINEAR_EMAIL,
+        createdAt: "2026-07-20T13:00:00.000Z"
+      },
+      {
+        id: "comment_2",
+        issue: "Wire MCP tools to commands",
+        body: "MCP list_issues should match GraphQL issues.",
+        user: "dev@pome-twin.test",
+        createdAt: "2026-07-20T17:00:00.000Z"
+      },
+      {
+        id: "comment_3",
+        issue: "Triage inbox for agent eval",
+        body: "@Pome Agent please prioritize this.",
+        user: DEFAULT_LINEAR_EMAIL,
+        createdAt: "2026-07-20T11:00:00.000Z"
+      }
+    ],
+    oauthApps: [
+      {
+        id: "oauth_app_1",
+        clientId: "lin_example_client_id",
+        clientSecret: "example_client_secret",
+        name: "Pome Linear App",
+        redirectUris: ["http://localhost:3000/api/auth/callback/linear"],
+        scopes: [...DEFAULT_SCOPES],
+        actor: "user",
+        assignable: true,
+        mentionable: true,
+        appUserId: "user_agent"
+      }
+    ],
+    tokens: [
+      {
+        token: DEFAULT_LINEAR_TOKEN,
+        type: "personal",
+        user: DEFAULT_LINEAR_EMAIL,
+        scopes: [...DEFAULT_SCOPES],
+        actor: "user",
+        sid: DEFAULT_LINEAR_SID
+      }
+    ],
+    webhooks: [
+      {
+        id: "webhook_1",
+        label: "Sample webhook",
+        url: "http://127.0.0.1:9999/linear-hooks",
+        resourceTypes: ["Issue", "Comment"],
+        team: "ENG",
+        allPublicTeams: false,
+        secret: "whsec_test_linear",
+        enabled: true
+      }
+    ]
+  };
+}
+
+export { ACCESS_TOKEN_TTL_SECONDS, BODY_MAX_BYTES, DEFAULT_LINEAR_CLOCK, DEFAULT_LINEAR_EMAIL, DEFAULT_LINEAR_PORT, DEFAULT_LINEAR_SID, DEFAULT_LINEAR_TOKEN, DEFAULT_SCOPES, GRAPHQL_QUERY_MAX_BYTES, GRAPHQL_SELECTION_DEPTH_MAX, LINEAR_PROVIDER_TOKEN_PREFIX, LinearTwinError, MCP_PAGE_DEFAULT, MCP_PAGE_MAX, OAUTH_CODE_TTL_SECONDS, RELAY_PAGE_DEFAULT, RELAY_PAGE_MAX, STATE_EXPORT_CAP, TITLE_MAX_BYTES, assertWebhookUrl, badUserInput, defaultSeedState, linearErrorEnvelope, linearSeedSchema, loadSeedFromEnv, notFound, parseSeed, unauthorizedEnvelope, unsupportedEnvelope, webhookUrlError };

package/dist/{runDemo-M3GEOJLT.js → runDemo-BCB6EDDN.js}

@@ -1,17 +1,16 @@
 import { newGroupId, reassuranceBox, twinReadyLine, trialsHeaderLine, trialLine, summaryLines, evaluatingLine, criterionPhrase } from './chunk-RGZBC7NF.js';
 import { DemoCapacityError, capacityLabel, parseCapacityMarker, capacityKindFrom } from './chunk-ZX4WNSZ5.js';
-import { runTask, demoTaskPath, DEMO_TASK_NAME, DEMO_REPO } from './chunk-NWXONLFF.js';
+import { runTask, demoTaskPath, DEMO_TASK_NAME, DEMO_REPO } from './chunk-WR7KP3LE.js';
 import { getAvailablePort } from './chunk-XDU6TD4O.js';
 import './chunk-CBFKZZBR.js';
-import { createHostedClient, parseTaskFile, uploadRunBlobs, scoreFromFinalizeResponse, scoreStatus, outcomeOf } from './chunk-CLGRZY53.js';
+import { createHostedClient, parseTaskFile, uploadRunBlobs, scoreFromFinalizeResponse, scoreStatus, outcomeOf } from './chunk-4ILBTPO4.js';
 import './chunk-NW7HGA2K.js';
 import { HostedQuotaError, HostedOrchError } from './chunk-PQYIAA6K.js';
-import './chunk-OKDJRKJV.js';
-import './chunk-WVWV7DLA.js';
-import './chunk-APAS34RJ.js';
-import './chunk-NY55QTVQ.js';
-import { bootTwin } from './chunk-JQQPZQOJ.js';
-import './chunk-MBM7LY7E.js';
+import './chunk-SGDUD7KK.js';
+import './chunk-NJ246QPJ.js';
+import './chunk-ZKID2HS3.js';
+import { bootTwin } from './chunk-M3X6OT4N.js';
+import './chunk-A3IDZXJY.js';
 import './chunk-LZIPGCQJ.js';
 import './chunk-VBATFCWR.js';
 import './chunk-SG6ZTIMT.js';

package/dist/{runTrialGroup-QQNDVHMR.js → runTrialGroup-YCSGW56C.js}

@@ -1,14 +1,13 @@
 import { newGroupId, criterionPhrase } from './chunk-RGZBC7NF.js';
-import { runTaskHosted, resolveRunAgentIdentity } from './chunk-OMVRPIBP.js';
+import { runTaskHosted, resolveRunAgentIdentity } from './chunk-JULH5ECU.js';
 import './chunk-KUVTL4NZ.js';
-import { createHostedClient, parseTaskFile, outcomeOf } from './chunk-CLGRZY53.js';
+import { createHostedClient, parseTaskFile, outcomeOf } from './chunk-4ILBTPO4.js';
 import './chunk-NW7HGA2K.js';
 import { HostedQuotaError, HostedTrialError } from './chunk-PQYIAA6K.js';
-import './chunk-OKDJRKJV.js';
-import './chunk-WVWV7DLA.js';
-import './chunk-APAS34RJ.js';
-import './chunk-NY55QTVQ.js';
-import './chunk-MBM7LY7E.js';
+import './chunk-SGDUD7KK.js';
+import './chunk-NJ246QPJ.js';
+import './chunk-ZKID2HS3.js';
+import './chunk-A3IDZXJY.js';
 import './chunk-LZIPGCQJ.js';
 import './chunk-VBATFCWR.js';
 import './chunk-SG6ZTIMT.js';