@mastra/factory 0.0.0-aggregate-trace-20261015182851

package/dist/integrations/incidentio/integration.js

@@ -0,0 +1,141 @@
+import { IssueReconcileWorker } from "../issue-reconcile-worker.js";
+import { IncidentioApiClient } from "./api.js";
+import { buildIncidentioRoutes } from "./routes.js";
+import { buildIncidentioAgentTools } from "./agent-tools.js";
+import { resolveIncidentioRules } from "./default-rules.js";
+import { createIncidentioIntake } from "./intake.js";
+import { attachIncidentioRules } from "./rules.js";
+import { attachIncidentioIssueReconciler } from "./issue-reconciler.js";
+import { incidentioReconciliationEnabled, incidentioReconciliationInterval } from "./reconciliation-config.js";
+//#region src/integrations/incidentio/integration.ts
+const DIRECT_CONNECTION_TOKEN = "incidentio-direct-api-key";
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var IncidentioIntegration = class {
+	id = "incidentio";
+	intake;
+	#endpointHost;
+	#rules;
+	/** Bound once by the factory via `initialize()` before any surface is used. */
+	#projects;
+	#auth;
+	#intakeStorage;
+	#orgIdByResourceId = /* @__PURE__ */ new Map();
+	constructor(config = {}) {
+		this.#rules = resolveIncidentioRules(config.rules);
+		const apiKey = config.apiKey?.trim() || process.env.INCIDENT_IO_API_KEY?.trim();
+		if (!apiKey) throw new Error("IncidentioIntegration: missing required INCIDENT_IO_API_KEY.");
+		const baseUrl = config.baseUrl ?? "https://api.incident.io";
+		this.#endpointHost = new URL(baseUrl).host;
+		const api = new IncidentioApiClient({
+			baseUrl,
+			accessToken: apiKey,
+			...config.fetchImpl ? { fetchImpl: config.fetchImpl } : {}
+		});
+		this.intake = createIncidentioIntake({
+			api,
+			connection: {
+				type: "oauth",
+				accessToken: DIRECT_CONNECTION_TOKEN
+			}
+		});
+	}
+	/** Event rules driving automatic follow-up materialization and close handling. */
+	get rules() {
+		return this.#rules;
+	}
+	/**
+	* Bind the projects domain and the host auth seam. incident.io has no
+	* per-org connection rows here — credentials are deployment-global
+	* constructor config.
+	*/
+	initialize({ projects, auth, intake }) {
+		this.#projects = projects;
+		this.#auth = auth;
+		this.#intakeStorage = intake;
+	}
+	/** Cross-integration intake selection/binding domain — agent-tool authorization. */
+	get intakeStorage() {
+		if (!this.#intakeStorage) throw new Error("IncidentioIntegration is not initialized — the factory binds storage during prepare().");
+		return this.#intakeStorage;
+	}
+	/** Factory projects domain — maps a session's resourceId to its owning org. */
+	get projects() {
+		if (!this.#projects) throw new Error("IncidentioIntegration is not initialized — the factory binds storage during prepare().");
+		return this.#projects;
+	}
+	/** Whether the host runs with web auth enabled; every surface is inert without it. */
+	get authEnabled() {
+		return this.#auth?.enabled() ?? false;
+	}
+	/**
+	* Map a session's resourceId (the factory project id) to its owning org.
+	* Same caching semantics as the Jira integration: definitive misses are
+	* cached, transient database failures are not.
+	*/
+	async resolveOrgId(resourceId) {
+		const cached = this.#orgIdByResourceId.get(resourceId);
+		if (cached !== void 0) return cached;
+		if (!UUID_PATTERN.test(resourceId)) {
+			this.#orgIdByResourceId.set(resourceId, null);
+			return null;
+		}
+		let orgId;
+		try {
+			await this.projects.ensureReady();
+			orgId = (await this.projects.getById({ id: resourceId }))?.orgId ?? null;
+		} catch {
+			return null;
+		}
+		this.#orgIdByResourceId.set(resourceId, orgId);
+		return orgId;
+	}
+	/** Test hook: clear the org cache between specs. */
+	clearCaches() {
+		this.#orgIdByResourceId.clear();
+	}
+	/**
+	* Org-scoped agent tools: the read-only follow-up detail tool for sessions
+	* whose resource is a factory project, matching the Linear/Jira surface.
+	*/
+	async agentTools(args) {
+		return buildIncidentioAgentTools({
+			requestContext: args.requestContext,
+			incidentio: this
+		});
+	}
+	workers(ctx) {
+		if (!incidentioReconciliationEnabled()) return [];
+		const reconcile = attachIncidentioIssueReconciler(this, ctx);
+		if (!reconcile) return [];
+		const intervalMs = incidentioReconciliationInterval();
+		return [new IssueReconcileWorker({
+			integrationId: this.id,
+			reconcile,
+			...intervalMs ? { intervalMs } : {}
+		})];
+	}
+	/**
+	* The integration's HTTP surface: `/web/incidentio/*` Mastra `apiRoutes`
+	* (status + follow-up listing/detail for Intake). Handlers operate on this
+	* instance; a board-scoped listing also feeds the incident.io event rules.
+	*/
+	routes(ctx) {
+		return buildIncidentioRoutes({
+			incidentio: this,
+			mode: "api-key",
+			auth: ctx.auth,
+			intake: ctx.storage.intake,
+			ingestFactoryIssues: attachIncidentioRules(this, ctx)
+		});
+	}
+	diagnostics() {
+		return {
+			mode: "api-key",
+			endpointHost: this.#endpointHost
+		};
+	}
+};
+//#endregion
+export { IncidentioIntegration };
+
+//# sourceMappingURL=integration.js.map

package/dist/integrations/incidentio/integration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration.js","names":["#endpointHost","#rules","#orgIdByResourceId","#projects","#auth","#intakeStorage"],"sources":["../../../src/integrations/incidentio/integration.ts"],"sourcesContent":["import type { RequestContext } from '@mastra/core/request-context';\nimport type { ApiRoute } from '@mastra/core/server';\nimport type { MastraWorker } from '@mastra/core/worker';\n\nimport type { RouteAuth } from '../../routes/route.js';\nimport type { IntakeStorage } from '../../storage/domains/intake/base.js';\nimport type { FactoryProjectsStorage } from '../../storage/domains/projects/base.js';\nimport type { FactoryIntegration, IntegrationContext, IntegrationTools } from '../base.js';\nimport { IssueReconcileWorker } from '../issue-reconcile-worker.js';\nimport { buildIncidentioAgentTools } from './agent-tools.js';\nimport { IncidentioApiClient } from './api.js';\nimport { resolveIncidentioRules } from './default-rules.js';\nimport type { IncidentioEventRules, IncidentioRuleOverrides } from './default-rules.js';\nimport { createIncidentioIntake } from './intake.js';\nimport { attachIncidentioIssueReconciler } from './issue-reconciler.js';\nimport { incidentioReconciliationEnabled, incidentioReconciliationInterval } from './reconciliation-config.js';\nimport { buildIncidentioRoutes } from './routes.js';\nimport { attachIncidentioRules } from './rules.js';\n\nexport interface IncidentioIntegrationConfig {\n  apiKey?: string;\n  fetchImpl?: typeof fetch;\n  baseUrl?: string;\n  /** Per-event replacements for the default Factory incident.io rules. */\n  rules?: IncidentioRuleOverrides;\n}\n\nconst DIRECT_CONNECTION_TOKEN = 'incidentio-direct-api-key';\nconst UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;\n\nexport class IncidentioIntegration implements FactoryIntegration {\n  readonly id = 'incidentio';\n  readonly intake;\n  readonly #endpointHost: string;\n  readonly #rules: IncidentioEventRules;\n\n  /** Bound once by the factory via `initialize()` before any surface is used. */\n  #projects: FactoryProjectsStorage | undefined;\n  #auth: RouteAuth | undefined;\n  #intakeStorage: IntakeStorage | undefined;\n  readonly #orgIdByResourceId = new Map<string, string | null>();\n\n  constructor(config: IncidentioIntegrationConfig = {}) {\n    this.#rules = resolveIncidentioRules(config.rules);\n    const apiKey = config.apiKey?.trim() || process.env.INCIDENT_IO_API_KEY?.trim();\n    if (!apiKey) {\n      throw new Error('IncidentioIntegration: missing required INCIDENT_IO_API_KEY.');\n    }\n    const baseUrl = config.baseUrl ?? 'https://api.incident.io';\n    this.#endpointHost = new URL(baseUrl).host;\n    const api = new IncidentioApiClient({\n      baseUrl,\n      accessToken: apiKey,\n      ...(config.fetchImpl ? { fetchImpl: config.fetchImpl } : {}),\n    });\n    this.intake = createIncidentioIntake({\n      api,\n      connection: { type: 'oauth', accessToken: DIRECT_CONNECTION_TOKEN },\n    });\n  }\n\n  /** Event rules driving automatic follow-up materialization and close handling. */\n  get rules(): IncidentioEventRules {\n    return this.#rules;\n  }\n\n  /**\n   * Bind the projects domain and the host auth seam. incident.io has no\n   * per-org connection rows here — credentials are deployment-global\n   * constructor config.\n   */\n  initialize({\n    projects,\n    auth,\n    intake,\n  }: {\n    projects: FactoryProjectsStorage;\n    auth: RouteAuth;\n    intake: IntakeStorage;\n  }): void {\n    this.#projects = projects;\n    this.#auth = auth;\n    this.#intakeStorage = intake;\n  }\n\n  /** Cross-integration intake selection/binding domain — agent-tool authorization. */\n  get intakeStorage(): IntakeStorage {\n    if (!this.#intakeStorage) {\n      throw new Error('IncidentioIntegration is not initialized — the factory binds storage during prepare().');\n    }\n    return this.#intakeStorage;\n  }\n\n  /** Factory projects domain — maps a session's resourceId to its owning org. */\n  get projects(): FactoryProjectsStorage {\n    if (!this.#projects) {\n      throw new Error('IncidentioIntegration is not initialized — the factory binds storage during prepare().');\n    }\n    return this.#projects;\n  }\n\n  /** Whether the host runs with web auth enabled; every surface is inert without it. */\n  get authEnabled(): boolean {\n    return this.#auth?.enabled() ?? false;\n  }\n\n  /**\n   * Map a session's resourceId (the factory project id) to its owning org.\n   * Same caching semantics as the Jira integration: definitive misses are\n   * cached, transient database failures are not.\n   */\n  async resolveOrgId(resourceId: string): Promise<string | null> {\n    const cached = this.#orgIdByResourceId.get(resourceId);\n    if (cached !== undefined) return cached;\n    if (!UUID_PATTERN.test(resourceId)) {\n      this.#orgIdByResourceId.set(resourceId, null);\n      return null;\n    }\n    let orgId: string | null;\n    try {\n      await this.projects.ensureReady();\n      const project = await this.projects.getById({ id: resourceId });\n      orgId = project?.orgId ?? null;\n    } catch {\n      // Transient database failure: skip the tools for this request but don't\n      // cache the miss, so the next request retries the lookup.\n      return null;\n    }\n    this.#orgIdByResourceId.set(resourceId, orgId);\n    return orgId;\n  }\n\n  /** Test hook: clear the org cache between specs. */\n  clearCaches(): void {\n    this.#orgIdByResourceId.clear();\n  }\n\n  /**\n   * Org-scoped agent tools: the read-only follow-up detail tool for sessions\n   * whose resource is a factory project, matching the Linear/Jira surface.\n   */\n  async agentTools(args: { requestContext: RequestContext }): Promise<IntegrationTools> {\n    return buildIncidentioAgentTools({ requestContext: args.requestContext, incidentio: this });\n  }\n\n  workers(ctx: IntegrationContext): MastraWorker[] {\n    if (!incidentioReconciliationEnabled()) return [];\n    const reconcile = attachIncidentioIssueReconciler(this, ctx);\n    if (!reconcile) return [];\n    const intervalMs = incidentioReconciliationInterval();\n    return [\n      new IssueReconcileWorker({\n        integrationId: this.id,\n        reconcile,\n        ...(intervalMs ? { intervalMs } : {}),\n      }),\n    ];\n  }\n\n  /**\n   * The integration's HTTP surface: `/web/incidentio/*` Mastra `apiRoutes`\n   * (status + follow-up listing/detail for Intake). Handlers operate on this\n   * instance; a board-scoped listing also feeds the incident.io event rules.\n   */\n  routes(ctx: IntegrationContext): ApiRoute[] {\n    return buildIncidentioRoutes({\n      incidentio: this,\n      mode: 'api-key',\n      auth: ctx.auth,\n      intake: ctx.storage.intake,\n      ingestFactoryIssues: attachIncidentioRules(this, ctx),\n    });\n  }\n\n  diagnostics(): Record<string, unknown> {\n    return { mode: 'api-key', endpointHost: this.#endpointHost };\n  }\n}\n"],"mappings":";;;;;;;;;;AA2BA,MAAM,0BAA0B;AAChC,MAAM,eAAe;AAErB,IAAa,wBAAb,MAAiE;CAC/D,KAAc;CACd;CACA;CACA;;CAGA;CACA;CACA;CACA,qCAA8B,IAAI,IAA2B;CAE7D,YAAY,SAAsC,CAAC,GAAG;EACpD,KAAKC,SAAS,uBAAuB,OAAO,KAAK;EACjD,MAAM,SAAS,OAAO,QAAQ,KAAK,KAAK,QAAQ,IAAI,qBAAqB,KAAK;EAC9E,IAAI,CAAC,QACH,MAAM,IAAI,MAAM,8DAA8D;EAEhF,MAAM,UAAU,OAAO,WAAW;EAClC,KAAKD,gBAAgB,IAAI,IAAI,OAAO,CAAC,CAAC;EACtC,MAAM,MAAM,IAAI,oBAAoB;GAClC;GACA,aAAa;GACb,GAAI,OAAO,YAAY,EAAE,WAAW,OAAO,UAAU,IAAI,CAAC;EAC5D,CAAC;EACD,KAAK,SAAS,uBAAuB;GACnC;GACA,YAAY;IAAE,MAAM;IAAS,aAAa;GAAwB;EACpE,CAAC;CACH;;CAGA,IAAI,QAA8B;EAChC,OAAO,KAAKC;CACd;;;;;;CAOA,WAAW,EACT,UACA,MACA,UAKO;EACP,KAAKE,YAAY;EACjB,KAAKC,QAAQ;EACb,KAAKC,iBAAiB;CACxB;;CAGA,IAAI,gBAA+B;EACjC,IAAI,CAAC,KAAKA,gBACR,MAAM,IAAI,MAAM,wFAAwF;EAE1G,OAAO,KAAKA;CACd;;CAGA,IAAI,WAAmC;EACrC,IAAI,CAAC,KAAKF,WACR,MAAM,IAAI,MAAM,wFAAwF;EAE1G,OAAO,KAAKA;CACd;;CAGA,IAAI,cAAuB;EACzB,OAAO,KAAKC,OAAO,QAAQ,KAAK;CAClC;;;;;;CAOA,MAAM,aAAa,YAA4C;EAC7D,MAAM,SAAS,KAAKF,mBAAmB,IAAI,UAAU;EACrD,IAAI,WAAW,KAAA,GAAW,OAAO;EACjC,IAAI,CAAC,aAAa,KAAK,UAAU,GAAG;GAClC,KAAKA,mBAAmB,IAAI,YAAY,IAAI;GAC5C,OAAO;EACT;EACA,IAAI;EACJ,IAAI;GACF,MAAM,KAAK,SAAS,YAAY;GAEhC,SAAQ,MADc,KAAK,SAAS,QAAQ,EAAE,IAAI,WAAW,CAAC,EAAA,EAC7C,SAAS;EAC5B,QAAQ;GAGN,OAAO;EACT;EACA,KAAKA,mBAAmB,IAAI,YAAY,KAAK;EAC7C,OAAO;CACT;;CAGA,cAAoB;EAClB,KAAKA,mBAAmB,MAAM;CAChC;;;;;CAMA,MAAM,WAAW,MAAqE;EACpF,OAAO,0BAA0B;GAAE,gBAAgB,KAAK;GAAgB,YAAY;EAAK,CAAC;CAC5F;CAEA,QAAQ,KAAyC;EAC/C,IAAI,CAAC,gCAAgC,GAAG,OAAO,CAAC;EAChD,MAAM,YAAY,gCAAgC,MAAM,GAAG;EAC3D,IAAI,CAAC,WAAW,OAAO,CAAC;EACxB,MAAM,aAAa,iCAAiC;EACpD,OAAO,CACL,IAAI,qBAAqB;GACvB,eAAe,KAAK;GACpB;GACA,GAAI,aAAa,EAAE,WAAW,IAAI,CAAC;EACrC,CAAC,CACH;CACF;;;;;;CAOA,OAAO,KAAqC;EAC1C,OAAO,sBAAsB;GAC3B,YAAY;GACZ,MAAM;GACN,MAAM,IAAI;GACV,QAAQ,IAAI,QAAQ;GACpB,qBAAqB,sBAAsB,MAAM,GAAG;EACtD,CAAC;CACH;CAEA,cAAuC;EACrC,OAAO;GAAE,MAAM;GAAW,cAAc,KAAKF;EAAc;CAC7D;AACF"}

package/dist/integrations/incidentio/issue-reconciler.d.ts

@@ -0,0 +1,10 @@
+import type { Intake } from '../../capabilities/intake.js';
+import type { IntegrationContext } from '../base.js';
+import type { IssueReconciler } from '../issue-reconciler.js';
+import type { IncidentioEventRules } from './default-rules.js';
+export type IncidentioIssueReconciler = IssueReconciler;
+export declare function attachIncidentioIssueReconciler(incidentio: {
+    intake: Intake;
+    rules: IncidentioEventRules;
+}, context: IntegrationContext): IncidentioIssueReconciler | undefined;
+//# sourceMappingURL=issue-reconciler.d.ts.map

package/dist/integrations/incidentio/issue-reconciler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"issue-reconciler.d.ts","sourceRoot":"","sources":["../../../src/integrations/incidentio/issue-reconciler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,8BAA8B,CAAC;AACxE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAErD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAI/D,MAAM,MAAM,yBAAyB,GAAG,eAAe,CAAC;AAoBxD,wBAAgB,+BAA+B,CAC7C,UAAU,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,oBAAoB,CAAA;CAAE,EAC3D,OAAO,EAAE,kBAAkB,GAC1B,yBAAyB,GAAG,SAAS,CAkDvC"}

package/dist/integrations/incidentio/issue-reconciler.js

@@ -0,0 +1,75 @@
+import { workItemPhaseSemantics } from "../../boards/semantics.js";
+import "../../boards/index.js";
+import { createIssueReconciler } from "../issue-reconciler.js";
+import { IncidentioRules } from "./rules.js";
+//#region src/integrations/incidentio/issue-reconciler.ts
+function issueToIngress(itemRef, issue) {
+	return {
+		id: itemRef,
+		identifier: issue.identifier,
+		title: issue.title,
+		url: issue.url,
+		state: issue.state ?? "",
+		stateType: issue.stateType ?? "",
+		priorityLabel: issue.priority ?? "",
+		assignee: issue.assignee ?? null,
+		author: issue.author ?? null,
+		incident: null,
+		labels: [...issue.labels ?? []],
+		createdAt: issue.createdAt,
+		updatedAt: issue.updatedAt
+	};
+}
+function attachIncidentioIssueReconciler(incidentio, context) {
+	if (!context.runtime || !incidentio.intake.resolveIntakeDispatch) return void 0;
+	const boards = context.runtime.boards;
+	const rules = new IncidentioRules({
+		projects: context.storage.projects,
+		storage: context.runtime.workItems,
+		configVersion: context.runtime.configVersion,
+		boards,
+		incidentioRules: incidentio.rules
+	});
+	return createIssueReconciler({
+		integrationId: "incidentio",
+		intake: incidentio.intake,
+		projects: context.storage.projects,
+		storage: context.runtime.workItems,
+		isTerminal: (item) => workItemPhaseSemantics(boards, item)?.kind === "terminal",
+		issueId: (item) => item.externalSource?.externalId,
+		metadata: (item, issue) => ({
+			identifier: issue.identifier,
+			issueRef: item.externalSource?.externalId ?? issue.id,
+			autoStartCandidate: issue.stateType === "unstarted" || issue.stateType === "started",
+			incidentioItemType: issue.source === "Follow-up" ? "follow-up" : "incident",
+			incidentioState: issue.state,
+			incidentioStateType: issue.stateType,
+			incidentioPriority: issue.priority,
+			incidentioAssignee: issue.assignee,
+			incidentioDescription: "description" in issue && typeof issue.description === "string" ? issue.description : null,
+			state: issue.state,
+			stateType: issue.stateType,
+			priority: issue.priority,
+			source: issue.source,
+			assignee: issue.assignee,
+			assignees: issue.assignees ?? [],
+			creator: issue.author,
+			author: issue.author,
+			labels: issue.labels ?? [],
+			createdAt: issue.createdAt,
+			updatedAt: issue.updatedAt
+		}),
+		onClosed: async (item, issue, project) => {
+			await rules.ingest({
+				orgId: project.orgId,
+				userId: "factory-rule-dispatcher",
+				factoryProjectId: project.id,
+				issues: [issueToIngress(item.externalSource?.externalId ?? issue.id, issue)]
+			});
+		}
+	});
+}
+//#endregion
+export { attachIncidentioIssueReconciler };
+
+//# sourceMappingURL=issue-reconciler.js.map

package/dist/integrations/incidentio/issue-reconciler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"issue-reconciler.js","names":[],"sources":["../../../src/integrations/incidentio/issue-reconciler.ts"],"sourcesContent":["import { workItemPhaseSemantics } from '../../boards/index.js';\nimport type { Intake, IntakeIssue } from '../../capabilities/intake.js';\nimport type { IntegrationContext } from '../base.js';\nimport { createIssueReconciler } from '../issue-reconciler.js';\nimport type { IssueReconciler } from '../issue-reconciler.js';\nimport type { IncidentioEventRules } from './default-rules.js';\nimport { IncidentioRules } from './rules.js';\nimport type { IncidentioIssueIngress } from './rules.js';\n\nexport type IncidentioIssueReconciler = IssueReconciler;\n\nfunction issueToIngress(itemRef: string, issue: IntakeIssue): IncidentioIssueIngress {\n  return {\n    id: itemRef,\n    identifier: issue.identifier,\n    title: issue.title,\n    url: issue.url,\n    state: issue.state ?? '',\n    stateType: issue.stateType ?? '',\n    priorityLabel: issue.priority ?? '',\n    assignee: issue.assignee ?? null,\n    author: issue.author ?? null,\n    incident: null,\n    labels: [...(issue.labels ?? [])],\n    createdAt: issue.createdAt,\n    updatedAt: issue.updatedAt,\n  };\n}\n\nexport function attachIncidentioIssueReconciler(\n  incidentio: { intake: Intake; rules: IncidentioEventRules },\n  context: IntegrationContext,\n): IncidentioIssueReconciler | undefined {\n  if (!context.runtime || !incidentio.intake.resolveIntakeDispatch) return undefined;\n  const boards = context.runtime.boards;\n\n  const rules = new IncidentioRules({\n    projects: context.storage.projects,\n    storage: context.runtime.workItems,\n    configVersion: context.runtime.configVersion,\n    boards,\n    incidentioRules: incidentio.rules,\n  });\n\n  return createIssueReconciler({\n    integrationId: 'incidentio',\n    intake: incidentio.intake,\n    projects: context.storage.projects,\n    storage: context.runtime.workItems,\n    isTerminal: item => workItemPhaseSemantics(boards, item)?.kind === 'terminal',\n    issueId: item => item.externalSource?.externalId,\n    metadata: (item, issue) => ({\n      identifier: issue.identifier,\n      issueRef: item.externalSource?.externalId ?? issue.id,\n      autoStartCandidate: issue.stateType === 'unstarted' || issue.stateType === 'started',\n      incidentioItemType: issue.source === 'Follow-up' ? 'follow-up' : 'incident',\n      incidentioState: issue.state,\n      incidentioStateType: issue.stateType,\n      incidentioPriority: issue.priority,\n      incidentioAssignee: issue.assignee,\n      incidentioDescription: 'description' in issue && typeof issue.description === 'string' ? issue.description : null,\n      state: issue.state,\n      stateType: issue.stateType,\n      priority: issue.priority,\n      source: issue.source,\n      assignee: issue.assignee,\n      assignees: issue.assignees ?? [],\n      creator: issue.author,\n      author: issue.author,\n      labels: issue.labels ?? [],\n      createdAt: issue.createdAt,\n      updatedAt: issue.updatedAt,\n    }),\n    onClosed: async (item, issue, project) => {\n      await rules.ingest({\n        orgId: project.orgId,\n        userId: 'factory-rule-dispatcher',\n        factoryProjectId: project.id,\n        issues: [issueToIngress(item.externalSource?.externalId ?? issue.id, issue)],\n      });\n    },\n  });\n}\n"],"mappings":";;;;;AAWA,SAAS,eAAe,SAAiB,OAA4C;CACnF,OAAO;EACL,IAAI;EACJ,YAAY,MAAM;EAClB,OAAO,MAAM;EACb,KAAK,MAAM;EACX,OAAO,MAAM,SAAS;EACtB,WAAW,MAAM,aAAa;EAC9B,eAAe,MAAM,YAAY;EACjC,UAAU,MAAM,YAAY;EAC5B,QAAQ,MAAM,UAAU;EACxB,UAAU;EACV,QAAQ,CAAC,GAAI,MAAM,UAAU,CAAC,CAAE;EAChC,WAAW,MAAM;EACjB,WAAW,MAAM;CACnB;AACF;AAEA,SAAgB,gCACd,YACA,SACuC;CACvC,IAAI,CAAC,QAAQ,WAAW,CAAC,WAAW,OAAO,uBAAuB,OAAO,KAAA;CACzE,MAAM,SAAS,QAAQ,QAAQ;CAE/B,MAAM,QAAQ,IAAI,gBAAgB;EAChC,UAAU,QAAQ,QAAQ;EAC1B,SAAS,QAAQ,QAAQ;EACzB,eAAe,QAAQ,QAAQ;EAC/B;EACA,iBAAiB,WAAW;CAC9B,CAAC;CAED,OAAO,sBAAsB;EAC3B,eAAe;EACf,QAAQ,WAAW;EACnB,UAAU,QAAQ,QAAQ;EAC1B,SAAS,QAAQ,QAAQ;EACzB,aAAY,SAAQ,uBAAuB,QAAQ,IAAI,CAAC,EAAE,SAAS;EACnE,UAAS,SAAQ,KAAK,gBAAgB;EACtC,WAAW,MAAM,WAAW;GAC1B,YAAY,MAAM;GAClB,UAAU,KAAK,gBAAgB,cAAc,MAAM;GACnD,oBAAoB,MAAM,cAAc,eAAe,MAAM,cAAc;GAC3E,oBAAoB,MAAM,WAAW,cAAc,cAAc;GACjE,iBAAiB,MAAM;GACvB,qBAAqB,MAAM;GAC3B,oBAAoB,MAAM;GAC1B,oBAAoB,MAAM;GAC1B,uBAAuB,iBAAiB,SAAS,OAAO,MAAM,gBAAgB,WAAW,MAAM,cAAc;GAC7G,OAAO,MAAM;GACb,WAAW,MAAM;GACjB,UAAU,MAAM;GAChB,QAAQ,MAAM;GACd,UAAU,MAAM;GAChB,WAAW,MAAM,aAAa,CAAC;GAC/B,SAAS,MAAM;GACf,QAAQ,MAAM;GACd,QAAQ,MAAM,UAAU,CAAC;GACzB,WAAW,MAAM;GACjB,WAAW,MAAM;EACnB;EACA,UAAU,OAAO,MAAM,OAAO,YAAY;GACxC,MAAM,MAAM,OAAO;IACjB,OAAO,QAAQ;IACf,QAAQ;IACR,kBAAkB,QAAQ;IAC1B,QAAQ,CAAC,eAAe,KAAK,gBAAgB,cAAc,MAAM,IAAI,KAAK,CAAC;GAC7E,CAAC;EACH;CACF,CAAC;AACH"}

package/dist/integrations/incidentio/reconciliation-config.d.ts

@@ -0,0 +1,3 @@
+export declare function incidentioReconciliationEnabled(): boolean;
+export declare function incidentioReconciliationInterval(): number | undefined;
+//# sourceMappingURL=reconciliation-config.d.ts.map

package/dist/integrations/incidentio/reconciliation-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconciliation-config.d.ts","sourceRoot":"","sources":["../../../src/integrations/incidentio/reconciliation-config.ts"],"names":[],"mappings":"AAIA,wBAAgB,+BAA+B,IAAI,OAAO,CAQzD;AAED,wBAAgB,gCAAgC,IAAI,MAAM,GAAG,SAAS,CAQrE"}

package/dist/integrations/incidentio/reconciliation-config.js

@@ -0,0 +1,17 @@
+import { optionalBoolean, optionalPositiveInteger } from "../reconciliation-config.js";
+//#region src/integrations/incidentio/reconciliation-config.ts
+const RECONCILIATION_LABEL = "incident.io reconciliation";
+function incidentioReconciliationEnabled() {
+	return optionalBoolean("MASTRACODE_INCIDENT_IO_RECONCILE_ENABLED", process.env.MASTRACODE_INCIDENT_IO_RECONCILE_ENABLED, RECONCILIATION_LABEL) ?? true;
+}
+function incidentioReconciliationInterval() {
+	const name = "MASTRACODE_INCIDENT_IO_RECONCILE_INTERVAL_MS";
+	const value = process.env.MASTRACODE_INCIDENT_IO_RECONCILE_INTERVAL_MS;
+	const interval = optionalPositiveInteger(value);
+	if (value?.trim() && interval === void 0) console.warn(`[${RECONCILIATION_LABEL}] ${name} must be a positive integer; received ${JSON.stringify(value)}.`);
+	return interval;
+}
+//#endregion
+export { incidentioReconciliationEnabled, incidentioReconciliationInterval };
+
+//# sourceMappingURL=reconciliation-config.js.map

package/dist/integrations/incidentio/reconciliation-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconciliation-config.js","names":[],"sources":["../../../src/integrations/incidentio/reconciliation-config.ts"],"sourcesContent":["import { optionalBoolean, optionalPositiveInteger } from '../reconciliation-config.js';\n\nconst RECONCILIATION_LABEL = 'incident.io reconciliation';\n\nexport function incidentioReconciliationEnabled(): boolean {\n  return (\n    optionalBoolean(\n      'MASTRACODE_INCIDENT_IO_RECONCILE_ENABLED',\n      process.env.MASTRACODE_INCIDENT_IO_RECONCILE_ENABLED,\n      RECONCILIATION_LABEL,\n    ) ?? true\n  );\n}\n\nexport function incidentioReconciliationInterval(): number | undefined {\n  const name = 'MASTRACODE_INCIDENT_IO_RECONCILE_INTERVAL_MS';\n  const value = process.env.MASTRACODE_INCIDENT_IO_RECONCILE_INTERVAL_MS;\n  const interval = optionalPositiveInteger(value);\n  if (value?.trim() && interval === undefined) {\n    console.warn(`[${RECONCILIATION_LABEL}] ${name} must be a positive integer; received ${JSON.stringify(value)}.`);\n  }\n  return interval;\n}\n"],"mappings":";;AAEA,MAAM,uBAAuB;AAE7B,SAAgB,kCAA2C;CACzD,OACE,gBACE,4CACA,QAAQ,IAAI,0CACZ,oBACF,KAAK;AAET;AAEA,SAAgB,mCAAuD;CACrE,MAAM,OAAO;CACb,MAAM,QAAQ,QAAQ,IAAI;CAC1B,MAAM,WAAW,wBAAwB,KAAK;CAC9C,IAAI,OAAO,KAAK,KAAK,aAAa,KAAA,GAChC,QAAQ,KAAK,IAAI,qBAAqB,IAAI,KAAK,wCAAwC,KAAK,UAAU,KAAK,EAAE,EAAE;CAEjH,OAAO;AACT"}

package/dist/integrations/incidentio/routes.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Mastra `apiRoutes` for the incident.io intake feature.
+ *
+ * Registered alongside the other `/web/*` routes, behind the host auth gate.
+ * Mirrors the Jira module: no connect/callback flow here — credentials are
+ * either deployment-global constructor config (direct) or Platform-managed
+ * connections discovered at runtime. Every route re-resolves the
+ * authenticated user from the request and scopes intake selections by the
+ * caller's org.
+ *
+ * When the feature is disabled (no auth, or no intake storage),
+ * `buildIncidentioRoutes` returns only `GET /web/incidentio/status`, which
+ * reports `enabled:false` so the SPA can cleanly hide all incident.io UI.
+ */
+import type { ApiRoute } from '@mastra/core/server';
+import type { Intake } from '../../capabilities/intake.js';
+import type { RouteAuth } from '../../routes/route.js';
+import type { IntakeStorage } from '../../storage/domains/intake/base.js';
+import type { IncidentioRulesIngress } from './rules.js';
+/**
+ * Non-secret diagnostic snapshot of every incident.io feature gate, mirroring
+ * the Jira diagnostics shape. Only booleans — never values.
+ */
+export interface IncidentioFeatureDiagnostics {
+    incidentioConfigured: boolean;
+    factoryAuthEnabled: boolean;
+}
+export interface MountIncidentioRoutesOptions {
+    /**
+     * The integration's intake capability providing incident.io access. Required
+     * for everything beyond the disabled `status` route.
+     */
+    incidentio?: {
+        intake: Intake;
+        id: string;
+    };
+    /**
+     * Credential mode reported on the status route so the SPA can tell a
+     * deployment-configured API key apart from Platform-managed connections.
+     */
+    mode?: 'api-key' | 'platform';
+    /** Host auth seam. Intake selections are org-owned, so the feature is inert without it. */
+    auth: RouteAuth;
+    /**
+     * Cross-integration intake selection domain. Required for the issues route's
+     * project filter; when absent, only the disabled `status` route is served.
+     */
+    intake?: IntakeStorage;
+    /**
+     * Factory rules ingress for observed follow-ups. When present, a
+     * board-scoped listing also materializes new cards through the incident.io
+     * event rules — the same automatic intake Linear and Jira have.
+     */
+    ingestFactoryIssues?: (input: IncidentioRulesIngress) => Promise<unknown>;
+}
+/**
+ * Narrow the caller's selected incident.io sources to the ones that feed this
+ * Factory project. Routing is explicit: a source feeds this Factory only when
+ * its binding names both the Factory project and a board. Mirrors the Jira
+ * routes' scoping semantics — the generic binding storage is provider-neutral.
+ * Shared with the agent tools, which enforce the same source-level
+ * authorization before fetching item details.
+ */
+export declare function scopeSourceIdsToProject({ intake, orgId, factoryProjectId, selectedIds, }: {
+    intake: IntakeStorage;
+    orgId: string;
+    factoryProjectId: string;
+    selectedIds: string[];
+}): Promise<Record<string, string>>;
+/**
+ * Build the incident.io routes as Mastra `apiRoutes`. When the feature is
+ * disabled, returns only the `status` route so the SPA can detect the
+ * disabled state.
+ */
+export declare function buildIncidentioRoutes(options: MountIncidentioRoutesOptions): ApiRoute[];
+//# sourceMappingURL=routes.d.ts.map

package/dist/integrations/incidentio/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../../src/integrations/incidentio/routes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAIpD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAC;AAC3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAE1E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAazD;;;GAGG;AACH,MAAM,WAAW,4BAA4B;IAC3C,oBAAoB,EAAE,OAAO,CAAC;IAC9B,kBAAkB,EAAE,OAAO,CAAC;CAC7B;AAED,MAAM,WAAW,4BAA4B;IAC3C;;;OAGG;IACH,UAAU,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC;IAC5C;;;OAGG;IACH,IAAI,CAAC,EAAE,SAAS,GAAG,UAAU,CAAC;IAC9B,2FAA2F;IAC3F,IAAI,EAAE,SAAS,CAAC;IAChB;;;OAGG;IACH,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,CAAC,KAAK,EAAE,sBAAsB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CAC3E;AAED;;;;;;;GAOG;AACH,wBAAsB,uBAAuB,CAAC,EAC5C,MAAM,EACN,KAAK,EACL,gBAAgB,EAChB,WAAW,GACZ,EAAE;IACD,MAAM,EAAE,aAAa,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,gBAAgB,EAAE,MAAM,CAAC;IACzB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CASlC;AAqED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,4BAA4B,GAAG,QAAQ,EAAE,CAiNvF"}

package/dist/integrations/incidentio/routes.js

@@ -0,0 +1,249 @@
+import { IncidentioApiError } from "./api.js";
+import { registerApiRoute } from "@mastra/core/server";
+//#region src/integrations/incidentio/routes.ts
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const ITEM_REF_RE = /^incidentio:(?:follow-up|incident):[\w-]+$/;
+const FOLLOW_UP_PREFIX = "incidentio:follow-up:";
+/** Erase a route handler's path-parameterized context to a plain `Context`. */
+function loose(c) {
+	return c;
+}
+/**
+* Narrow the caller's selected incident.io sources to the ones that feed this
+* Factory project. Routing is explicit: a source feeds this Factory only when
+* its binding names both the Factory project and a board. Mirrors the Jira
+* routes' scoping semantics — the generic binding storage is provider-neutral.
+* Shared with the agent tools, which enforce the same source-level
+* authorization before fetching item details.
+*/
+async function scopeSourceIdsToProject({ intake, orgId, factoryProjectId, selectedIds }) {
+	const selected = new Set(selectedIds);
+	const intakeBoards = {};
+	for (const binding of await intake.listBindings({
+		orgId,
+		integrationId: "incidentio"
+	})) if (binding.factoryProjectId === factoryProjectId && binding.board && selected.has(binding.sourceId)) intakeBoards[binding.sourceId] = binding.board;
+	return intakeBoards;
+}
+/**
+* Resolve the org-scoped tenant for an incident.io request. Intake selections
+* are org-owned, so it requires both a signed-in user and an organization.
+*/
+async function resolveOrgTenant(c, auth) {
+	await auth.ensureUser(c);
+	const tenant = auth.tenant(c);
+	if (!tenant) return { response: c.json({ error: "unauthorized" }, 401) };
+	if (!tenant.orgId) return { response: c.json({
+		error: "organization_required",
+		message: "incident.io intake requires an organization. Personal accounts cannot use incident.io intake."
+	}, 403) };
+	return { tenant: {
+		orgId: tenant.orgId,
+		userId: tenant.userId
+	} };
+}
+/**
+* Validate an opaque pagination cursor from the query string. Cursors are
+* server-issued base64url blobs, so anything outside a conservative
+* charset/length is rejected rather than decoded.
+*/
+function parseAfterCursor(raw) {
+	if (raw === void 0 || raw === "") return void 0;
+	if (raw.length > 2048 || !/^[\w+/=.:-]+$/.test(raw)) return null;
+	return raw;
+}
+/** Map an incident.io read failure to the API response for the SPA. */
+function incidentioFetchError(c, err) {
+	if (err instanceof IncidentioApiError && (err.status === 401 || err.status === 403)) return c.json({
+		error: "incidentio_auth_failed",
+		message: "incident.io rejected the configured credentials. Reconnect the incident.io account."
+	}, 409);
+	return c.json({
+		error: "incidentio_fetch_failed",
+		message: err instanceof Error ? err.message : String(err)
+	}, 502);
+}
+/**
+* Build the incident.io routes as Mastra `apiRoutes`. When the feature is
+* disabled, returns only the `status` route so the SPA can detect the
+* disabled state.
+*/
+function buildIncidentioRoutes(options) {
+	const routes = [];
+	const { incidentio, auth, intake, mode } = options;
+	const enabled = Boolean(incidentio) && auth.enabled();
+	const modeField = mode ? { mode } : {};
+	const diagnostics = () => ({
+		incidentioConfigured: Boolean(incidentio),
+		factoryAuthEnabled: auth.enabled()
+	});
+	routes.push(registerApiRoute("/web/incidentio/status", {
+		method: "GET",
+		requiresAuth: false,
+		handler: async (c) => {
+			if (!enabled || !incidentio || !intake) return c.json({
+				enabled: false,
+				configured: Boolean(incidentio),
+				...modeField,
+				reason: "missing_config",
+				diagnostics: diagnostics()
+			});
+			await auth.ensureUser(loose(c));
+			const tenant = auth.tenant(loose(c));
+			if (!tenant) return c.json({
+				error: "unauthorized",
+				reason: "auth_required"
+			}, 401);
+			if (!tenant.orgId) return c.json({
+				enabled: true,
+				configured: true,
+				...modeField,
+				organizationRequired: true,
+				reason: "organization_required",
+				diagnostics: diagnostics()
+			});
+			return c.json({
+				enabled: true,
+				configured: true,
+				...modeField,
+				reason: "ready",
+				diagnostics: diagnostics()
+			});
+		}
+	}));
+	if (!enabled || !incidentio || !intake) return routes;
+	routes.push(registerApiRoute("/web/incidentio/issues", {
+		method: "GET",
+		requiresAuth: false,
+		handler: async (c) => {
+			const resolved = await resolveOrgTenant(loose(c), auth);
+			if ("response" in resolved) return resolved.response;
+			const after = parseAfterCursor(c.req.query("after"));
+			if (after === null) return c.json({ error: "invalid_cursor" }, 400);
+			const factoryProjectId = c.req.query("factoryProjectId");
+			if (factoryProjectId && !UUID_RE.test(factoryProjectId)) return c.json({ error: "invalid_factory_project_id" }, 400);
+			await intake.ensureReady();
+			const selection = (await intake.getConfig({
+				orgId: resolved.tenant.orgId,
+				integrationIds: ["incidentio"]
+			})).incidentio;
+			if (!selection.enabled) return c.json({
+				error: "incidentio_intake_disabled",
+				message: "incident.io intake is turned off in Settings."
+			}, 404);
+			const selectedIds = selection.sourceIds ?? [];
+			const intakeBoards = factoryProjectId ? await scopeSourceIdsToProject({
+				intake,
+				orgId: resolved.tenant.orgId,
+				factoryProjectId,
+				selectedIds
+			}) : null;
+			const sourceIds = intakeBoards ? Object.keys(intakeBoards) : selectedIds;
+			if (sourceIds.length === 0) return c.json({
+				issues: [],
+				nextCursor: null
+			});
+			try {
+				const page = await incidentio.intake.listItems({
+					orgId: resolved.tenant.orgId,
+					userId: resolved.tenant.userId,
+					sourceIds,
+					...after ? { cursor: after } : {}
+				});
+				const issuePayload = [];
+				for (const item of page.items) {
+					const externalId = item.source.externalId;
+					if (!externalId.startsWith(FOLLOW_UP_PREFIX)) continue;
+					const metadata = item.metadata ?? {};
+					const identifier = typeof metadata.identifier === "string" ? metadata.identifier : externalId;
+					const titlePrefix = `${identifier}: `;
+					issuePayload.push({
+						id: externalId,
+						identifier,
+						title: item.title.startsWith(titlePrefix) ? item.title.slice(titlePrefix.length) : item.title,
+						url: item.source.url ?? "",
+						author: typeof metadata.author === "string" ? metadata.author : null,
+						state: item.status ?? "",
+						stateType: typeof metadata.stateType === "string" ? metadata.stateType : "",
+						priorityLabel: typeof metadata.priority === "string" ? metadata.priority : "",
+						assignee: item.assignee ?? null,
+						incident: typeof metadata.incidentioIncidentId === "string" ? metadata.incidentioIncidentId : null,
+						labels: item.labels ?? [],
+						createdAt: item.createdAt ?? "",
+						updatedAt: item.updatedAt ?? "",
+						sourceId: item.sourceId || null
+					});
+				}
+				if (factoryProjectId && intakeBoards && options.ingestFactoryIssues) await options.ingestFactoryIssues({
+					orgId: resolved.tenant.orgId,
+					userId: resolved.tenant.userId,
+					factoryProjectId,
+					issues: issuePayload,
+					intakeBoards
+				});
+				return c.json({
+					issues: issuePayload,
+					nextCursor: page.nextCursor
+				});
+			} catch (err) {
+				return incidentioFetchError(loose(c), err);
+			}
+		}
+	}));
+	routes.push(registerApiRoute("/web/incidentio/issues/detail", {
+		method: "GET",
+		requiresAuth: false,
+		handler: async (c) => {
+			const resolved = await resolveOrgTenant(loose(c), auth);
+			if ("response" in resolved) return resolved.response;
+			const factoryProjectId = c.req.query("factoryProjectId");
+			const issueRef = c.req.query("issueRef");
+			if (!factoryProjectId || !UUID_RE.test(factoryProjectId)) return c.json({ error: "invalid_factory_project_id" }, 400);
+			if (!issueRef || issueRef.length > 2048 || !ITEM_REF_RE.test(issueRef)) return c.json({ error: "invalid_issue_ref" }, 400);
+			await intake.ensureReady();
+			const selection = (await intake.getConfig({
+				orgId: resolved.tenant.orgId,
+				integrationIds: ["incidentio"]
+			})).incidentio;
+			if (!selection.enabled) return c.json({
+				error: "incidentio_intake_disabled",
+				message: "incident.io intake is turned off in Settings."
+			}, 404);
+			const intakeBoards = await scopeSourceIdsToProject({
+				intake,
+				orgId: resolved.tenant.orgId,
+				factoryProjectId,
+				selectedIds: selection.sourceIds ?? []
+			});
+			if (Object.keys(intakeBoards).length === 0) return c.json({ error: "issue_not_found" }, 404);
+			try {
+				const dispatch = await incidentio.intake.resolveIntakeDispatch?.({
+					orgId: resolved.tenant.orgId,
+					externalSource: {
+						type: "issue",
+						externalId: issueRef
+					}
+				});
+				if (!dispatch || !dispatch.sourceId || !(dispatch.sourceId in intakeBoards)) return c.json({ error: "issue_not_found" }, 404);
+				const issue = await incidentio.intake.getIssue({
+					connection: dispatch.connection,
+					issueId: dispatch.issueId
+				});
+				if (!issue) return c.json({ error: "issue_not_found" }, 404);
+				return c.json({ issue: {
+					identifier: issue.identifier,
+					title: issue.title,
+					url: issue.url,
+					description: issue.description ?? null
+				} });
+			} catch (err) {
+				return incidentioFetchError(loose(c), err);
+			}
+		}
+	}));
+	return routes;
+}
+//#endregion
+export { buildIncidentioRoutes, scopeSourceIdsToProject };
+
+//# sourceMappingURL=routes.js.map