@perstack/api-client 0.0.45 → 0.0.47

package/dist/index.mjs

@@ -0,0 +1,2011 @@
+import { r as __toESM, t as __commonJSMin } from "./chunk-Bdv87wj9.mjs";
+import { z } from "zod";
+import { activityOrGroupSchema, checkpointSchema as perstackCheckpointSchema, instructionMessageSchema, messageSchema, stepSchema, toolCallSchema, toolMessageSchema, toolResultSchema, usageSchema, userMessageSchema } from "@perstack/core";
+
+//#region ../constants/index.ts
+const organizationNameRegex = /^[a-z0-9][a-z0-9_.-]*$/;
+const maxOrganizationNameLength = 128;
+const maxApplicationNameLength = 255;
+const expertKeyRegex = /^((?:@[a-z0-9][a-z0-9_.-]*\/)?[a-z0-9][a-z0-9_.-]*)(?:@((?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[\w.-]+)?(?:\+[\w.-]+)?)|@([a-z0-9][a-z0-9_.-]*))?$/;
+const expertNameRegex = /^(@[a-z0-9][a-z0-9_-]*\/)?[a-z0-9][a-z0-9_-]*$/;
+const scopeNameRegex = /^[a-z0-9][a-z0-9_-]*$/;
+const scopeNameRefRegex = /^[a-z0-9][a-z0-9_-]*(?:@(?:(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[\w.-]+)?(?:\+[\w.-]+)?|[a-z0-9][a-z0-9_-]*))?$/;
+const expertVersionRegex = /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[\w.-]+)?(?:\+[\w.-]+)?$/;
+const tagNameRegex = /^[a-z0-9][a-z0-9_-]*$/;
+const maxExpertNameLength = 255;
+const maxExpertVersionTagLength = 255;
+const maxExpertKeyLength = 511;
+const maxExpertDescriptionLength = 1024 * 2;
+const maxExpertInstructionLength = 1024 * 20;
+const maxExpertDelegateItems = 255;
+const maxExpertTagItems = 8;
+const maxExpertJobQueryLength = 1024 * 20;
+const maxExpertJobFileNameLength = 1024 * 10;
+const packageWithVersionRegex = /^(?:@[a-z0-9][a-z0-9_.-]*\/)?[a-z0-9][a-z0-9_.-]*(?:@(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[\w.-]+)?(?:\+[\w.-]+)?|@[a-z0-9][a-z0-9_.-]*)?$/;
+const urlSafeRegex = /^[a-z0-9][a-z0-9_-]*$/;
+const maxSkillNameLength = 255;
+const maxSkillDescriptionLength = 1024 * 2;
+const maxSkillRuleLength = 1024 * 2;
+const maxSkillPickOmitItems = 255;
+const maxSkillRequiredEnvItems = 255;
+const maxSkillToolNameLength = 255;
+const maxSkillEndpointLength = 1024 * 2;
+const maxSkillInputJsonSchemaLength = 1024 * 20;
+const maxCheckpointToolCallIdLength = 255;
+const envNameRegex = /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/;
+const maxEnvNameLength = 255;
+const maxProviderBaseUrlLength = 2048;
+const maxProviderHeaderKeyLength = 255;
+const maxProviderHeaderValueLength = 2048;
+const maxProviderHeadersCount = 50;
+
+//#endregion
+//#region ../models/src/domain/common.ts
+const cuidSchema = z.cuid2();
+const runtimeVersionSchema = z.enum(["v1.0"]);
+const providerSchema = z.enum([
+	"anthropic",
+	"google",
+	"openai",
+	"ollama",
+	"deepseek",
+	"azure-openai",
+	"amazon-bedrock",
+	"google-vertex"
+]);
+const datetimeSchema = z.string().datetime();
+const expertKeyFieldSchema = z.string().min(1).max(maxExpertKeyLength).regex(expertKeyRegex);
+const expertNameFieldSchema = z.string().min(1).max(maxExpertNameLength).regex(expertNameRegex);
+const expertVersionFieldSchema = z.string().min(1).max(maxExpertVersionTagLength).regex(expertVersionRegex);
+const expertTagFieldSchema = z.string().min(1).max(maxExpertVersionTagLength).regex(tagNameRegex);
+const expertCategoryFieldSchema = z.enum([
+	"general",
+	"coding",
+	"research",
+	"writing",
+	"data",
+	"automation"
+]);
+const scopeNameSchema = z.string().min(1).max(maxExpertNameLength).regex(scopeNameRegex);
+const scopeNameRefSchema = z.string().min(1).max(maxExpertNameLength + maxExpertVersionTagLength + 1).regex(scopeNameRefRegex);
+const draftRefFieldSchema = z.string().min(1).max(30);
+
+//#endregion
+//#region ../models/src/domain/organization.ts
+const organizationStatusSchema = z.enum([
+	"active",
+	"inactive",
+	"deleted"
+]);
+const organizationTypeSchema = z.enum([
+	"personal",
+	"personalPlus",
+	"team",
+	"serviceAdmin"
+]);
+const organizationSchema = z.object({
+	type: z.literal("organization"),
+	id: cuidSchema,
+	createdAt: datetimeSchema,
+	updatedAt: datetimeSchema,
+	name: z.string().min(1).max(maxOrganizationNameLength).regex(organizationNameRegex).optional(),
+	nameChangedAt: datetimeSchema.optional(),
+	status: organizationStatusSchema,
+	organizationType: organizationTypeSchema,
+	maxApplications: z.number().int().min(0),
+	maxApiKeys: z.number().int().min(0),
+	maxExperts: z.number().int().min(0)
+});
+
+//#endregion
+//#region ../models/src/domain/application.ts
+const applicationNameSchema = z.string().min(1).max(maxApplicationNameLength);
+const applicationStatusSchema = z.enum([
+	"active",
+	"inactive",
+	"deleted"
+]);
+const applicationSchema = z.object({
+	type: z.literal("application"),
+	id: cuidSchema,
+	organizationId: cuidSchema,
+	organization: organizationSchema,
+	createdAt: datetimeSchema,
+	updatedAt: datetimeSchema,
+	name: applicationNameSchema,
+	status: applicationStatusSchema
+});
+
+//#endregion
+//#region ../models/src/api/applications/create.ts
+const request$38 = { body: z.object({
+	name: applicationNameSchema,
+	applicationGroupId: cuidSchema.optional()
+}) };
+const response$40 = z.object({ data: z.object({ application: applicationSchema }) });
+
+//#endregion
+//#region ../models/src/api/applications/delete.ts
+const request$37 = { params: z.object({ applicationId: cuidSchema }) };
+const response$39 = z.object({ data: z.object({ application: applicationSchema }) });
+
+//#endregion
+//#region ../models/src/api/applications/get.ts
+const request$36 = { params: z.object({ applicationId: cuidSchema }) };
+const response$38 = z.object({ data: z.object({ application: applicationSchema }) });
+
+//#endregion
+//#region ../../node_modules/ts-dedent/dist/index.js
+var require_dist = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.dedent = void 0;
+	function dedent(templ) {
+		var values = [];
+		for (var _i = 1; _i < arguments.length; _i++) values[_i - 1] = arguments[_i];
+		var strings = Array.from(typeof templ === "string" ? [templ] : templ);
+		strings[strings.length - 1] = strings[strings.length - 1].replace(/\r?\n([\t ]*)$/, "");
+		var indentLengths = strings.reduce(function(arr, str) {
+			var matches = str.match(/\n([\t ]+|(?!\s).)/g);
+			if (matches) return arr.concat(matches.map(function(match) {
+				var _a, _b;
+				return (_b = (_a = match.match(/[\t ]/g)) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+			}));
+			return arr;
+		}, []);
+		if (indentLengths.length) {
+			var pattern_1 = new RegExp("\n[	 ]{" + Math.min.apply(Math, indentLengths) + "}", "g");
+			strings = strings.map(function(str) {
+				return str.replace(pattern_1, "\n");
+			});
+		}
+		strings[0] = strings[0].replace(/^\r?\n/, "");
+		var string = strings[0];
+		values.forEach(function(value, i) {
+			var endentations = string.match(/(?:^|\n)( *)$/);
+			var endentation = endentations ? endentations[1] : "";
+			var indentedValue = value;
+			if (typeof value === "string" && value.includes("\n")) indentedValue = String(value).split("\n").map(function(str, i$1) {
+				return i$1 === 0 ? str : "" + endentation + str;
+			}).join("\n");
+			string += indentedValue + strings[i + 1];
+		});
+		return string;
+	}
+	exports.dedent = dedent;
+	exports.default = dedent;
+}));
+
+//#endregion
+//#region ../models/src/api/common.ts
+var import_dist = /* @__PURE__ */ __toESM(require_dist(), 1);
+const errorBadRequest = z.object({
+	code: z.literal(400),
+	error: z.literal("Bad Request"),
+	reason: z.string()
+}).describe("Bad Request");
+const errorUnauthorized = z.object({
+	code: z.literal(401),
+	error: z.literal("Unauthorized"),
+	reason: z.literal("Failed to authenticate")
+}).describe(import_dist.default`
+    Authentication failed. Possible reasons:
+    - Authorization header is not provided
+    - Invalid API key
+    - Session expired
+  `);
+const errorForbidden = z.object({
+	code: z.literal(403),
+	error: z.literal("Forbidden"),
+	reason: z.string()
+}).describe("Access denied. The authenticated user does not have permission to perform this action.");
+const errorNotFound = z.object({
+	code: z.literal(404),
+	error: z.literal("Not Found"),
+	reason: z.string()
+}).describe("Resource not found.");
+const errorValidationFailed = z.object({
+	code: z.literal(422),
+	error: z.literal("Validation Failed"),
+	reason: z.unknown()
+}).describe("Request validation failed. Check the request body, query parameters, or path parameters.");
+const paginationMeta = z.object({
+	total: z.number().int().min(0),
+	take: z.number().int().min(1),
+	skip: z.number().int().min(0)
+});
+const errorUnauthorizedFlexible = z.object({
+	code: z.literal(401),
+	error: z.literal("Unauthorized"),
+	reason: z.string()
+}).describe("Unauthorized");
+
+//#endregion
+//#region ../models/src/api/applications/getAll.ts
+const request$35 = { query: z.object({
+	name: z.union([z.string(), z.array(z.string())]).optional().transform((v) => Array.isArray(v) ? v.join(",") : v),
+	sort: z.enum([
+		"name",
+		"createdAt",
+		"updatedAt"
+	]).optional(),
+	order: z.enum(["asc", "desc"]).optional(),
+	take: z.coerce.number().min(1).max(100).default(100),
+	skip: z.coerce.number().min(0).default(0)
+}) };
+const response$37 = z.object({
+	data: z.object({ applications: z.array(applicationSchema) }),
+	meta: paginationMeta
+});
+
+//#endregion
+//#region ../models/src/api/applications/update.ts
+const request$34 = {
+	params: z.object({ applicationId: cuidSchema }),
+	body: z.object({
+		name: applicationNameSchema.optional(),
+		status: applicationStatusSchema.exclude(["deleted"]).optional()
+	}).refine((data) => data.name !== void 0 || data.status !== void 0, { message: "At least one field must be provided" })
+};
+const response$36 = z.object({ data: z.object({ application: applicationSchema }) });
+
+//#endregion
+//#region ../models/src/domain/secret.ts
+const secretNameSchema = z.string().min(1, "Secret name is required").max(255, "Secret name must be 255 characters or less").regex(/^[A-Z][A-Z0-9_]*$/, "Secret name must start with uppercase letter and contain only uppercase letters, numbers, and underscores");
+const secretValueSchema = z.string().min(1, "Secret value is required");
+const secretMetadataSchema = z.object({
+	name: z.string(),
+	createdAt: datetimeSchema,
+	updatedAt: datetimeSchema
+});
+const secretSchema = z.object({
+	type: z.literal("secret"),
+	id: cuidSchema,
+	name: secretNameSchema,
+	applicationId: cuidSchema,
+	createdAt: datetimeSchema,
+	updatedAt: datetimeSchema
+});
+
+//#endregion
+//#region ../models/src/api/env/secrets/create.ts
+const request$33 = { body: z.object({
+	applicationId: cuidSchema,
+	name: secretNameSchema,
+	value: secretValueSchema
+}) };
+const response$35 = z.object({ data: z.object({ secret: secretMetadataSchema }) });
+
+//#endregion
+//#region ../models/src/api/env/secrets/delete.ts
+const request$32 = {
+	params: z.object({ name: z.string().min(1) }),
+	query: z.object({ applicationId: cuidSchema })
+};
+const response$34 = z.null();
+
+//#endregion
+//#region ../models/src/api/env/secrets/get.ts
+const request$31 = {
+	params: z.object({ name: z.string().min(1) }),
+	query: z.object({ applicationId: cuidSchema })
+};
+const response$33 = z.object({ data: z.object({ secret: secretMetadataSchema }) });
+
+//#endregion
+//#region ../models/src/api/env/secrets/getAll.ts
+const request$30 = { query: z.object({ applicationId: cuidSchema.optional() }) };
+const response$32 = z.object({ data: z.object({ secrets: z.array(secretMetadataSchema) }) });
+
+//#endregion
+//#region ../models/src/api/env/secrets/update.ts
+const request$29 = {
+	params: z.object({ name: z.string().min(1) }),
+	body: z.object({
+		applicationId: cuidSchema,
+		value: secretValueSchema
+	})
+};
+const response$31 = z.object({ data: z.object({ secret: secretMetadataSchema }) });
+
+//#endregion
+//#region ../models/src/domain/variable.ts
+const variableNameSchema = z.string().min(1).max(255).regex(/^[A-Z_][A-Z0-9_]*$/, "Variable name must start with uppercase letter or underscore, and contain only uppercase letters, digits, and underscores");
+const variableValueSchema = z.string();
+const variableSchema = z.object({
+	type: z.literal("variable"),
+	id: cuidSchema,
+	applicationId: cuidSchema,
+	createdAt: datetimeSchema,
+	updatedAt: datetimeSchema,
+	name: variableNameSchema,
+	value: variableValueSchema
+});
+const variableResponseSchema = z.object({
+	name: variableNameSchema,
+	value: variableValueSchema,
+	createdAt: datetimeSchema,
+	updatedAt: datetimeSchema
+});
+
+//#endregion
+//#region ../models/src/api/env/variables/create.ts
+const request$28 = { body: z.object({
+	applicationId: cuidSchema,
+	name: variableNameSchema,
+	value: variableValueSchema
+}) };
+const response$30 = z.object({ data: z.object({ variable: variableResponseSchema }) });
+
+//#endregion
+//#region ../models/src/api/env/variables/delete.ts
+const request$27 = {
+	params: z.object({ name: z.string().min(1) }),
+	query: z.object({ applicationId: cuidSchema })
+};
+const response$29 = z.null();
+
+//#endregion
+//#region ../models/src/api/env/variables/get.ts
+const request$26 = {
+	params: z.object({ name: z.string().min(1) }),
+	query: z.object({ applicationId: cuidSchema })
+};
+const response$28 = z.object({ data: z.object({ variable: variableResponseSchema }) });
+
+//#endregion
+//#region ../models/src/api/env/variables/getAll.ts
+const request$25 = { query: z.object({ applicationId: cuidSchema }) };
+const response$27 = z.object({ data: z.object({ variables: z.array(variableResponseSchema) }) });
+
+//#endregion
+//#region ../models/src/api/env/variables/update.ts
+const request$24 = {
+	params: z.object({ name: z.string().min(1) }),
+	body: z.object({
+		applicationId: cuidSchema,
+		value: variableValueSchema
+	})
+};
+const response$26 = z.object({ data: z.object({ variable: variableResponseSchema }) });
+
+//#endregion
+//#region ../models/src/domain/expertScope.ts
+const expertScopeSchema = z.object({
+	id: cuidSchema,
+	name: scopeNameSchema,
+	organizationId: cuidSchema,
+	published: z.boolean(),
+	publishedAt: datetimeSchema.optional(),
+	category: expertCategoryFieldSchema,
+	totalRuns: z.number().int().min(0),
+	totalJobs: z.number().int().min(0),
+	totalStars: z.number().int().min(0),
+	createdAt: datetimeSchema,
+	updatedAt: datetimeSchema,
+	createdBy: cuidSchema,
+	updatedBy: cuidSchema
+});
+const expertVersionSchema = z.object({
+	id: cuidSchema,
+	expertScopeId: cuidSchema,
+	version: expertVersionFieldSchema,
+	public: z.boolean(),
+	yanked: z.boolean(),
+	totalRuns: z.number().int().min(0),
+	totalJobs: z.number().int().min(0),
+	createdAt: datetimeSchema,
+	updatedAt: datetimeSchema,
+	createdBy: cuidSchema,
+	updatedBy: cuidSchema,
+	tags: z.array(expertTagFieldSchema)
+});
+const expertScopeWithVersionsSchema = expertScopeSchema.extend({ versions: z.array(expertVersionSchema) });
+
+//#endregion
+//#region ../models/src/domain/skill.ts
+function isPrivateOrLocalIP(hostname) {
+	if (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "0.0.0.0") return true;
+	const ipv4Match = hostname.match(/^(\d+)\.(\d+)\.(\d+)\.(\d+)$/);
+	if (ipv4Match) {
+		const a = Number(ipv4Match[1]);
+		const b = Number(ipv4Match[2]);
+		if (a === 10) return true;
+		if (a === 172 && b >= 16 && b <= 31) return true;
+		if (a === 192 && b === 168) return true;
+		if (a === 169 && b === 254) return true;
+		if (a === 127) return true;
+	}
+	if (hostname.includes(":")) {
+		if (hostname.startsWith("fe80:") || hostname.startsWith("fc") || hostname.startsWith("fd")) return true;
+	}
+	if (hostname.startsWith("::ffff:")) {
+		if (isPrivateOrLocalIP(hostname.slice(7))) return true;
+	}
+	return false;
+}
+const sseEndpointSchema = z.string().max(maxSkillEndpointLength).url().refine((url) => {
+	try {
+		const parsed = new URL(url);
+		if (parsed.protocol !== "https:") return false;
+		if (isPrivateOrLocalIP(parsed.hostname)) return false;
+		return true;
+	} catch {
+		return false;
+	}
+}, { message: "Endpoint must be a public HTTPS URL" });
+const skillNameSchema = z.string().min(1).max(maxSkillNameLength).regex(packageWithVersionRegex);
+const mcpStdioSkillCommandSchema = z.enum(["npx", "uvx"]);
+const mcpStdioSkillSchema = z.object({
+	type: z.literal("mcpStdioSkill"),
+	name: z.string(),
+	description: z.string().min(1).max(maxSkillDescriptionLength),
+	rule: z.string().min(1).max(maxSkillRuleLength).optional(),
+	pick: z.array(z.string().min(1).max(maxSkillToolNameLength)).max(maxSkillPickOmitItems).optional().default([]),
+	omit: z.array(z.string().min(1).max(maxSkillToolNameLength)).max(maxSkillPickOmitItems).optional().default([]),
+	command: mcpStdioSkillCommandSchema,
+	packageName: z.string().min(1).max(maxSkillNameLength).regex(packageWithVersionRegex),
+	requiredEnv: z.array(z.string().min(1).max(maxEnvNameLength).regex(envNameRegex)).min(0).max(maxSkillRequiredEnvItems).optional()
+});
+const mcpSseSkillSchema = z.object({
+	type: z.literal("mcpSseSkill"),
+	name: z.string(),
+	description: z.string().min(1).max(maxSkillDescriptionLength),
+	rule: z.string().min(1).max(maxSkillRuleLength).optional(),
+	pick: z.array(z.string().min(1).max(maxSkillToolNameLength)).max(maxSkillPickOmitItems).optional().default([]),
+	omit: z.array(z.string().min(1).max(maxSkillToolNameLength)).max(maxSkillPickOmitItems).optional().default([]),
+	endpoint: sseEndpointSchema
+});
+const interactiveSkillSchema = z.object({
+	type: z.literal("interactiveSkill"),
+	name: z.string(),
+	description: z.string().min(1).max(maxSkillDescriptionLength),
+	rule: z.string().min(1).max(maxSkillRuleLength).optional(),
+	tools: z.record(z.string().min(1).max(maxSkillToolNameLength).regex(urlSafeRegex), z.object({
+		description: z.string().min(1).max(maxSkillDescriptionLength),
+		inputJsonSchema: z.string().min(1).max(maxSkillInputJsonSchemaLength)
+	}))
+});
+const skillSchema = z.discriminatedUnion("type", [
+	mcpStdioSkillSchema,
+	mcpSseSkillSchema,
+	interactiveSkillSchema
+]);
+
+//#endregion
+//#region ../models/src/domain/expert.ts
+const expertSchema = z.object({
+	key: expertKeyFieldSchema,
+	name: expertNameFieldSchema,
+	version: expertVersionFieldSchema,
+	description: z.string().min(1).max(maxExpertDescriptionLength).optional(),
+	instruction: z.string().min(1).max(maxExpertInstructionLength),
+	skills: z.record(skillNameSchema, skillSchema).optional().default({}),
+	delegates: z.array(expertKeyFieldSchema).min(0).max(maxExpertDelegateItems).optional().default([]),
+	tags: z.array(expertTagFieldSchema).min(0).max(maxExpertTagItems).optional().default([])
+});
+const expertMetadataSchema = z.object({
+	scope: expertScopeSchema,
+	version: expertVersionSchema
+});
+const expertWithMetadataSchema = expertSchema.extend({
+	scope: expertScopeSchema,
+	version: expertVersionSchema
+});
+
+//#endregion
+//#region ../models/src/api/experts/definition.ts
+const expertDefinitionSchema = z.object({
+	name: expertNameFieldSchema,
+	version: expertVersionFieldSchema,
+	organizationId: cuidSchema,
+	createdAt: datetimeSchema,
+	updatedAt: datetimeSchema,
+	createdBy: cuidSchema,
+	updatedBy: cuidSchema,
+	experts: z.record(expertKeyFieldSchema, expertSchema.omit({ key: true }))
+});
+
+//#endregion
+//#region ../models/src/api/experts/delete.ts
+const request$23 = { params: z.object({ scopeName: scopeNameRefSchema }) };
+const response$25 = z.object({ data: expertMetadataSchema.extend({
+	yanked: z.literal(true),
+	latestTagUpdated: z.boolean()
+}) });
+
+//#endregion
+//#region ../models/src/domain/expertDraftScope.ts
+const expertDraftScopeSchema = z.object({
+	id: cuidSchema,
+	name: scopeNameSchema,
+	organizationId: cuidSchema,
+	applicationId: cuidSchema,
+	totalRuns: z.number().int().min(0),
+	totalJobs: z.number().int().min(0),
+	createdAt: datetimeSchema,
+	updatedAt: datetimeSchema,
+	createdBy: cuidSchema,
+	updatedBy: cuidSchema
+});
+const expertDraftRefSchema = z.object({
+	id: cuidSchema,
+	expertDraftScopeId: cuidSchema,
+	totalRuns: z.number().int().min(0),
+	totalJobs: z.number().int().min(0),
+	createdAt: datetimeSchema,
+	updatedAt: datetimeSchema,
+	createdBy: cuidSchema,
+	updatedBy: cuidSchema
+});
+const expertDraftScopeWithRefsSchema = expertDraftScopeSchema.extend({ draftRefs: z.array(expertDraftRefSchema) });
+
+//#endregion
+//#region ../models/src/api/experts/drafts/definition.ts
+const expertDefinitionContentSchema = z.object({
+	name: expertNameFieldSchema,
+	version: z.literal("0.0.0-draft"),
+	applicationId: cuidSchema,
+	createdAt: datetimeSchema,
+	updatedAt: datetimeSchema,
+	createdBy: cuidSchema,
+	updatedBy: cuidSchema,
+	experts: z.record(expertKeyFieldSchema, expertSchema.omit({ key: true }))
+});
+
+//#endregion
+//#region ../models/src/api/experts/drafts/create.ts
+const request$22 = {
+	params: z.object({ scopeName: scopeNameSchema }),
+	body: z.object({
+		applicationId: cuidSchema,
+		experts: z.array(expertSchema)
+	})
+};
+const response$24 = z.object({ data: z.object({
+	scope: expertDraftScopeSchema,
+	draftRef: expertDraftRefSchema,
+	definition: expertDefinitionContentSchema
+}) });
+
+//#endregion
+//#region ../models/src/api/experts/drafts/delete.ts
+const request$21 = { params: z.object({
+	scopeName: scopeNameSchema,
+	draftRef: expertDraftRefSchema.shape.id
+}) };
+const response$23 = z.object({ data: z.object({
+	deleted: z.boolean(),
+	draftRef: z.string()
+}) });
+
+//#endregion
+//#region ../models/src/api/experts/drafts/get.ts
+const request$20 = { params: z.object({
+	scopeName: scopeNameSchema,
+	draftRef: expertDraftRefSchema.shape.id
+}) };
+const response$22 = z.object({ data: z.object({
+	scope: expertDraftScopeSchema,
+	draftRef: expertDraftRefSchema,
+	definition: expertDefinitionContentSchema
+}) });
+
+//#endregion
+//#region ../models/src/api/experts/drafts/getAll.ts
+const request$19 = {
+	params: z.object({ scopeName: expertDraftScopeSchema.shape.name }),
+	query: z.object({
+		limit: z.coerce.number().int().min(1).max(100).optional().default(20),
+		offset: z.coerce.number().int().min(0).optional().default(0)
+	})
+};
+const response$21 = z.object({ data: z.object({
+	draftRefs: z.array(expertDraftRefSchema),
+	total: z.number().int().min(0)
+}) });
+
+//#endregion
+//#region ../models/src/api/experts/drafts/update.ts
+const request$18 = {
+	params: z.object({
+		scopeName: scopeNameSchema,
+		draftRef: expertDraftRefSchema.shape.id
+	}),
+	body: z.object({ experts: z.array(expertSchema) })
+};
+const response$20 = z.object({ data: z.object({
+	scope: expertDraftScopeSchema,
+	draftRef: expertDraftRefSchema,
+	definition: expertDefinitionContentSchema
+}) });
+
+//#endregion
+//#region ../models/src/api/experts/drafts/version.ts
+const request$17 = {
+	params: z.object({
+		scopeName: scopeNameSchema,
+		draftRef: z.string().min(1)
+	}),
+	body: z.object({
+		version: z.string().min(1, "Version is required.").max(maxExpertVersionTagLength, "Version is too long.").regex(expertVersionRegex, "Invalid version format. (e.g. 1.0.0)"),
+		tag: z.string().max(maxExpertVersionTagLength, "Tag is too long.").regex(tagNameRegex, "Invalid tag format. (e.g. latest)").optional()
+	})
+};
+const response$19 = z.object({ data: z.object({
+	scope: expertScopeSchema,
+	version: expertVersionSchema,
+	definitionUrl: z.string()
+}) });
+
+//#endregion
+//#region ../models/src/api/experts/featured.ts
+const response$18 = z.object({ data: z.object({ featuredExperts: z.array(z.object({
+	scope: expertScopeSchema,
+	currentVersion: expertVersionSchema,
+	displayOrder: z.number().int().min(0).max(2),
+	featuredAt: z.string().datetime()
+})) }) });
+
+//#endregion
+//#region ../models/src/api/experts/get.ts
+const request$16 = { params: z.object({ scopeName: scopeNameRefSchema }) };
+const response$17 = z.object({ data: z.object({
+	definition: expertDefinitionSchema,
+	yanked: z.boolean().optional()
+}) });
+
+//#endregion
+//#region ../models/src/api/experts/getAll.ts
+const request$15 = { query: z.object({
+	filter: z.string().describe("Filter by scope name (partial match)").optional(),
+	category: z.enum([
+		"general",
+		"coding",
+		"research",
+		"writing",
+		"data",
+		"automation"
+	]).describe("Filter by category").optional(),
+	includeDrafts: z.coerce.boolean().default(false).describe("Include unpublished scopes (owner only)").optional(),
+	limit: z.coerce.number().min(1).max(100).default(20).describe("Maximum results").optional(),
+	offset: z.coerce.number().min(0).default(0).describe("Pagination offset").optional()
+}) };
+const response$16 = z.object({ data: z.object({
+	experts: z.array(expertScopeSchema.extend({ currentVersion: expertVersionSchema })),
+	total: z.number()
+}) });
+
+//#endregion
+//#region ../models/src/api/experts/meta.ts
+const request$14 = {
+	params: z.object({ scopeName: scopeNameRefSchema }),
+	query: z.object({ public: z.enum(["true", "false"]).transform((val) => val === "true").optional().default(false).describe("Public access check (no auth)") })
+};
+const response$15 = z.object({ data: expertMetadataSchema.extend({ definitionUrl: z.string() }) });
+
+//#endregion
+//#region ../models/src/api/experts/publish.ts
+const request$13 = { params: z.object({ scopeName: scopeNameSchema }) };
+const response$14 = z.object({ data: z.object({ scope: expertScopeSchema }) });
+
+//#endregion
+//#region ../models/src/api/experts/unpublish.ts
+const request$12 = { params: z.object({ scopeName: scopeNameSchema }) };
+const response$13 = z.object({ data: z.object({ scope: expertScopeSchema }) });
+
+//#endregion
+//#region ../models/src/api/experts/versions.ts
+const request$11 = { params: z.object({ scopeName: scopeNameSchema }) };
+const response$12 = z.object({ data: z.object({ versions: z.array(expertVersionSchema) }) });
+
+//#endregion
+//#region ../models/src/domain/checkpoint.ts
+const delegationTargetSchema = z.object({
+	expert: expertSchema,
+	toolCallId: z.string().min(1).max(maxCheckpointToolCallIdLength),
+	toolName: z.string().min(1).max(maxSkillToolNameLength),
+	query: z.string()
+});
+/**
+* API Checkpoint schema - extended checkpoint format for API responses.
+* Includes additional fields computed from runtime checkpoint and step data:
+* - activities: computed via getActivities() from @perstack/core
+* - inputMessages, newMessages, toolCalls, toolResults: step-related data
+* - expert: full Expert type (with instruction, skills, etc.)
+* - startedAt/finishedAt: ISO string format (runtime uses Unix timestamps)
+*/
+const apiCheckpointSchema = z.object({
+	type: z.literal("checkpoint"),
+	id: cuidSchema,
+	jobId: cuidSchema,
+	runId: cuidSchema,
+	activities: z.array(activityOrGroupSchema),
+	stepNumber: z.number().int().min(1),
+	status: z.enum([
+		"init",
+		"proceeding",
+		"completed",
+		"stoppedByInteractiveTool",
+		"stoppedByDelegate",
+		"stoppedByExceededMaxSteps",
+		"stoppedByError"
+	]),
+	expert: expertSchema,
+	delegateTo: z.array(delegationTargetSchema).optional(),
+	delegatedBy: z.object({
+		expert: expertSchema,
+		toolCallId: z.string().min(1).max(maxCheckpointToolCallIdLength),
+		toolName: z.string().min(1).max(maxSkillToolNameLength),
+		checkpointId: cuidSchema,
+		runId: cuidSchema
+	}).optional(),
+	inputMessages: z.array(z.union([
+		instructionMessageSchema,
+		userMessageSchema,
+		toolMessageSchema
+	])).optional(),
+	messages: z.array(messageSchema),
+	newMessages: z.array(messageSchema),
+	toolCalls: z.array(toolCallSchema).optional(),
+	toolResults: z.array(toolResultSchema).optional(),
+	pendingToolCalls: z.array(toolCallSchema).optional(),
+	partialToolResults: z.array(toolResultSchema).optional(),
+	usage: usageSchema,
+	contextWindow: z.number().int().min(0).optional(),
+	contextWindowUsage: z.number().int().min(0).optional(),
+	error: z.object({
+		name: z.string(),
+		message: z.string(),
+		statusCode: z.number().optional(),
+		isRetryable: z.boolean()
+	}).optional(),
+	retryCount: z.number().optional(),
+	startedAt: datetimeSchema,
+	finishedAt: datetimeSchema.optional()
+});
+
+//#endregion
+//#region ../models/src/api/jobs/checkpoints/create.ts
+/**
+* Request checkpoint schema - `id` and `runId` are omitted because:
+* - `id` is server-generated (CUID)
+* - `runId` is optional in request, server will use job's run ID
+*/
+const requestCheckpointSchema = perstackCheckpointSchema.omit({
+	id: true,
+	runId: true
+}).extend({ runId: z.string().optional() });
+const request$10 = {
+	params: z.object({ jobId: cuidSchema }),
+	body: z.object({
+		checkpoint: requestCheckpointSchema,
+		step: stepSchema
+	})
+};
+const response$11 = z.object({ data: z.object({ checkpoint: apiCheckpointSchema }) });
+
+//#endregion
+//#region ../models/src/api/jobs/checkpoints/get.ts
+const request$9 = { params: z.object({
+	jobId: cuidSchema,
+	checkpointId: cuidSchema
+}) };
+const response$10 = z.object({ data: z.object({ checkpoint: apiCheckpointSchema }) });
+
+//#endregion
+//#region ../models/src/api/jobs/checkpoints/getAll.ts
+const request$8 = {
+	params: z.object({ jobId: cuidSchema }),
+	query: z.object({
+		filter: z.string().min(1).max(256).optional(),
+		sort: z.enum(["createdAt", "updatedAt"]).optional(),
+		order: z.enum(["asc", "desc"]).optional(),
+		take: z.coerce.number().min(1).max(100).default(10),
+		skip: z.coerce.number().min(0).default(0)
+	})
+};
+const response$9 = z.object({
+	data: z.object({ checkpoints: z.array(apiCheckpointSchema) }),
+	meta: paginationMeta
+});
+
+//#endregion
+//#region ../models/src/api/jobs/checkpoints/stream.ts
+const request$7 = { params: z.object({ jobId: cuidSchema }) };
+const response$8 = z.object({ data: apiCheckpointSchema });
+
+//#endregion
+//#region ../support-models/src/index.ts
+const anthropicSupportModels = [
+	{
+		modelId: "claude-opus-4-5",
+		default: false,
+		provider: "anthropic",
+		contextWindow: 2e5
+	},
+	{
+		modelId: "claude-opus-4-1",
+		default: false,
+		provider: "anthropic",
+		contextWindow: 2e5
+	},
+	{
+		modelId: "claude-opus-4-20250514",
+		default: false,
+		provider: "anthropic",
+		contextWindow: 2e5
+	},
+	{
+		modelId: "claude-sonnet-4-5",
+		default: true,
+		provider: "anthropic",
+		contextWindow: 2e5
+	},
+	{
+		modelId: "claude-sonnet-4-20250514",
+		default: false,
+		provider: "anthropic",
+		contextWindow: 2e5
+	},
+	{
+		modelId: "claude-3-7-sonnet-20250219",
+		default: false,
+		provider: "anthropic",
+		contextWindow: 2e5
+	},
+	{
+		modelId: "claude-haiku-4-5",
+		default: false,
+		provider: "anthropic",
+		contextWindow: 2e5
+	},
+	{
+		modelId: "claude-3-5-haiku-latest",
+		default: false,
+		provider: "anthropic",
+		contextWindow: 2e5
+	}
+];
+const googleSupportModels = [
+	{
+		modelId: "gemini-3-pro-preview",
+		default: false,
+		provider: "google",
+		contextWindow: 1e6
+	},
+	{
+		modelId: "gemini-2.5-pro",
+		default: true,
+		provider: "google",
+		contextWindow: 1e6
+	},
+	{
+		modelId: "gemini-2.5-flash",
+		default: false,
+		provider: "google",
+		contextWindow: 1e6
+	},
+	{
+		modelId: "gemini-2.5-flash-lite",
+		default: false,
+		provider: "google",
+		contextWindow: 1e6
+	}
+];
+const openAiSupportModels = [
+	{
+		modelId: "gpt-5",
+		default: true,
+		provider: "openai",
+		contextWindow: 4e5
+	},
+	{
+		modelId: "gpt-5-mini",
+		default: false,
+		provider: "openai",
+		contextWindow: 4e5
+	},
+	{
+		modelId: "gpt-5-nano",
+		default: false,
+		provider: "openai",
+		contextWindow: 4e5
+	},
+	{
+		modelId: "gpt-5-chat-latest",
+		default: false,
+		provider: "openai",
+		contextWindow: 128e3
+	},
+	{
+		modelId: "o4-mini",
+		default: false,
+		provider: "openai",
+		contextWindow: 2e5
+	},
+	{
+		modelId: "o3",
+		default: false,
+		provider: "openai",
+		contextWindow: 2e5
+	},
+	{
+		modelId: "o3-mini",
+		default: false,
+		provider: "openai",
+		contextWindow: 2e5
+	},
+	{
+		modelId: "gpt-4.1",
+		default: false,
+		provider: "openai",
+		contextWindow: 1e6
+	}
+];
+const deepseekSupportModels = [{
+	modelId: "deepseek-chat",
+	default: true,
+	provider: "deepseek",
+	contextWindow: 128e3
+}, {
+	modelId: "deepseek-reasoner",
+	default: false,
+	provider: "deepseek",
+	contextWindow: 128e3
+}];
+const allSupportModels = [
+	...anthropicSupportModels,
+	...googleSupportModels,
+	...openAiSupportModels,
+	...deepseekSupportModels
+];
+const supportModels = Object.fromEntries(allSupportModels.map((model) => [model.modelId, model]));
+function getSupportModelNames() {
+	return Object.keys(supportModels);
+}
+
+//#endregion
+//#region ../models/src/domain/job.ts
+const reasoningBudgetSchema = z.union([z.enum([
+	"none",
+	"minimal",
+	"low",
+	"medium",
+	"high"
+]), z.number().min(0)]);
+const jobStatusSchema = z.enum([
+	"queued",
+	"processing",
+	"completed",
+	"requestInteractiveToolResult",
+	"requestDelegateResult",
+	"exceededMaxSteps",
+	"failed",
+	"canceling",
+	"canceled",
+	"expired"
+]);
+const modelNames = getSupportModelNames();
+const firstModel = modelNames[0];
+if (firstModel === void 0) throw new Error("No support models available");
+const modelEnum = z.enum([firstModel, ...modelNames.slice(1)]);
+const jobSchema = z.object({
+	type: z.literal("job"),
+	id: cuidSchema,
+	organizationId: cuidSchema,
+	applicationId: cuidSchema,
+	createdAt: datetimeSchema,
+	updatedAt: datetimeSchema,
+	status: jobStatusSchema,
+	coordinatorExpertKey: expertKeyFieldSchema,
+	query: z.string().min(1).max(maxExpertJobQueryLength).optional(),
+	files: z.array(z.string().min(1).max(maxExpertJobFileNameLength)),
+	expert: expertWithMetadataSchema,
+	provider: providerSchema,
+	model: modelEnum,
+	reasoningBudget: reasoningBudgetSchema,
+	maxSteps: z.number().int().min(1),
+	maxRetries: z.number().int().min(0),
+	currentStep: z.number().int().min(0),
+	totalSteps: z.number().int().min(0),
+	totalDuration: z.number().min(0),
+	usage: usageSchema
+});
+
+//#endregion
+//#region ../models/src/api/jobs/continue.ts
+const request$6 = {
+	params: z.object({ jobId: cuidSchema }),
+	body: z.object({
+		query: jobSchema.shape.query.optional(),
+		interactiveToolCallResult: z.boolean().optional(),
+		files: z.union([z.instanceof(File), z.array(z.instanceof(File))]).optional(),
+		provider: providerSchema.optional(),
+		model: jobSchema.shape.model.optional(),
+		reasoningBudget: reasoningBudgetSchema.optional(),
+		maxSteps: z.coerce.number().optional(),
+		maxRetries: z.coerce.number().optional()
+	})
+};
+const response$7 = z.object({ data: z.object({ job: jobSchema }) });
+
+//#endregion
+//#region ../models/src/api/jobs/create.ts
+const request$5 = { body: z.object({
+	applicationId: cuidSchema.describe("Application ID to create the job in"),
+	expertKey: expertKeyFieldSchema,
+	query: jobSchema.shape.query.optional(),
+	files: z.union([z.instanceof(File), z.array(z.instanceof(File))]).optional(),
+	provider: providerSchema,
+	model: jobSchema.shape.model.optional(),
+	reasoningBudget: reasoningBudgetSchema.optional(),
+	maxSteps: z.coerce.number().optional(),
+	maxRetries: z.coerce.number().optional()
+}) };
+const response$6 = z.object({ data: z.object({ job: jobSchema }) });
+
+//#endregion
+//#region ../models/src/api/jobs/get.ts
+const request$4 = { params: z.object({ jobId: cuidSchema }) };
+const response$5 = z.object({ data: z.object({ job: jobSchema }) });
+
+//#endregion
+//#region ../models/src/api/jobs/getAll.ts
+const request$3 = { query: z.object({
+	sort: z.enum(["createdAt", "updatedAt"]).optional(),
+	order: z.enum(["asc", "desc"]).optional(),
+	take: z.coerce.number().min(1).max(100).default(100),
+	skip: z.coerce.number().min(0).default(0)
+}) };
+const response$4 = z.object({
+	data: z.object({ jobs: z.array(jobSchema) }),
+	meta: paginationMeta
+});
+
+//#endregion
+//#region ../models/src/api/jobs/update.ts
+const request$2 = {
+	params: z.object({ jobId: cuidSchema }),
+	body: z.object({ status: jobStatusSchema })
+};
+const response$3 = z.object({ data: z.object({ job: jobSchema }) });
+
+//#endregion
+//#region ../models/src/api/jobs/workspace/get.ts
+const workspaceCommitSchema = z.object({
+	sha: z.string(),
+	message: z.string(),
+	author: z.string(),
+	timestamp: z.string()
+});
+const workspaceStatsSchema = z.object({
+	commits: z.number().int().min(0),
+	filesChanged: z.number().int().min(0),
+	additions: z.number().int().min(0),
+	deletions: z.number().int().min(0)
+});
+const workspaceSchema = z.object({
+	jobId: z.string(),
+	branch: z.string(),
+	baseBranch: z.string(),
+	lastCommit: workspaceCommitSchema.optional(),
+	stats: workspaceStatsSchema.optional()
+});
+const request$1 = { params: z.object({ jobId: cuidSchema }) };
+const response$2 = z.object({ data: z.object({ workspace: workspaceSchema }) });
+
+//#endregion
+//#region ../models/src/api/jobs/workspace/tree.ts
+const workspaceItemSchema = z.object({
+	type: z.enum(["directory", "file"]),
+	path: z.string(),
+	name: z.string(),
+	size: z.number().optional(),
+	sha: z.string().optional()
+});
+const request = {
+	params: z.object({ jobId: cuidSchema }),
+	query: z.object({
+		path: z.string().optional(),
+		recursive: z.coerce.boolean().optional()
+	})
+};
+const response$1 = z.object({ data: z.object({ items: z.array(workspaceItemSchema) }) });
+
+//#endregion
+//#region ../models/src/domain/user.ts
+const userStatusSchema = z.enum([
+	"active",
+	"inactive",
+	"deleted"
+]);
+const userSchema = z.object({
+	type: z.literal("user"),
+	id: cuidSchema,
+	email: z.string().email(),
+	emailVerified: z.boolean(),
+	name: z.string().min(1).max(255).optional(),
+	image: z.string().url().optional(),
+	status: userStatusSchema,
+	organizations: z.array(organizationSchema),
+	createdAt: datetimeSchema,
+	updatedAt: datetimeSchema
+});
+
+//#endregion
+//#region ../models/src/api/session/get.ts
+const response = z.object({ data: z.object({
+	user: userSchema,
+	organization: organizationSchema,
+	application: applicationSchema.nullable()
+}) });
+
+//#endregion
+//#region ../models/src/domain/apiKey.ts
+const apiKeyPermissionsSchema = z.object({
+	operations: z.array(z.string()),
+	experts: z.union([z.array(z.string()), z.literal("*")]).optional()
+});
+const apiKeySchema = z.object({
+	type: z.literal("apiKey"),
+	id: cuidSchema,
+	name: z.string().min(1).max(255).optional(),
+	start: z.string().optional(),
+	prefix: z.string().optional(),
+	user: userSchema.optional(),
+	enabled: z.boolean(),
+	expiresAt: datetimeSchema.optional(),
+	permissions: apiKeyPermissionsSchema.optional(),
+	lastRequest: datetimeSchema.optional(),
+	createdAt: datetimeSchema,
+	updatedAt: datetimeSchema
+});
+const createApiKeyInputSchema = z.object({
+	name: z.string().min(1).max(255).optional(),
+	organizationId: cuidSchema,
+	operations: z.array(z.string()).optional(),
+	experts: z.union([z.array(z.string()), z.literal("*")]).optional(),
+	expiresIn: z.number().min(60).optional()
+});
+const createApiKeyResponseSchema = z.object({
+	apiKey: apiKeySchema,
+	key: z.string()
+});
+
+//#endregion
+//#region ../models/src/domain/providerSetting.ts
+const baseUrlSchema = z.string().url().max(maxProviderBaseUrlLength).optional();
+const headersSchema = z.record(z.string().min(1).max(maxProviderHeaderKeyLength), z.string().max(maxProviderHeaderValueLength)).refine((headers) => Object.keys(headers).length <= maxProviderHeadersCount, { message: `Headers must have at most ${maxProviderHeadersCount} entries` }).optional();
+const anthropicProviderSettingsSchema = z.object({
+	baseUrl: baseUrlSchema,
+	headers: headersSchema
+});
+const googleProviderSettingsSchema = z.object({
+	baseUrl: baseUrlSchema,
+	headers: headersSchema
+});
+const openaiProviderSettingsSchema = z.object({
+	baseUrl: baseUrlSchema,
+	headers: headersSchema,
+	organization: z.string().optional(),
+	project: z.string().optional(),
+	name: z.string().optional()
+});
+const deepseekProviderSettingsSchema = z.object({
+	baseUrl: baseUrlSchema,
+	headers: headersSchema
+});
+const azureOpenaiProviderSettingsSchema = z.object({
+	baseUrl: baseUrlSchema,
+	headers: headersSchema,
+	resourceName: z.string().optional(),
+	apiVersion: z.string().optional(),
+	useDeploymentBasedUrls: z.boolean().optional()
+});
+const amazonBedrockProviderSettingsSchema = z.object({ region: z.string().optional() });
+const googleVertexProviderSettingsSchema = z.object({
+	baseUrl: baseUrlSchema,
+	headers: headersSchema,
+	project: z.string().optional(),
+	location: z.string().optional()
+});
+const providerSettingsSchema = z.union([
+	anthropicProviderSettingsSchema,
+	googleProviderSettingsSchema,
+	openaiProviderSettingsSchema,
+	deepseekProviderSettingsSchema,
+	azureOpenaiProviderSettingsSchema,
+	amazonBedrockProviderSettingsSchema,
+	googleVertexProviderSettingsSchema
+]);
+const providerSettingSchema = z.object({
+	type: z.literal("providerSetting"),
+	id: cuidSchema,
+	applicationId: cuidSchema,
+	provider: providerSchema,
+	settings: providerSettingsSchema.optional(),
+	application: applicationSchema,
+	createdAt: datetimeSchema,
+	updatedAt: datetimeSchema
+});
+
+//#endregion
+//#region ../models/src/domain/providerApiKey.ts
+const providerApiKeyNameSchema = z.string().min(1).max(255);
+const providerApiKeyValueSchema = z.string().min(1);
+const providerApiKeySchema = z.object({
+	type: z.literal("providerApiKey"),
+	id: cuidSchema,
+	providerSettingId: cuidSchema,
+	name: providerApiKeyNameSchema,
+	lastUsedAt: datetimeSchema.optional(),
+	expiresAt: datetimeSchema.optional(),
+	providerSetting: providerSettingSchema,
+	createdAt: datetimeSchema,
+	updatedAt: datetimeSchema
+});
+
+//#endregion
+//#region ../models/src/domain/run.ts
+const runStatusSchema = z.enum([
+	"queued",
+	"processing",
+	"completed",
+	"stoppedByInteractiveTool",
+	"stoppedByDelegate",
+	"stoppedByExceededMaxSteps",
+	"stoppedByError"
+]);
+const runSchema = z.object({
+	type: z.literal("run"),
+	id: cuidSchema,
+	jobId: cuidSchema,
+	parentRunId: cuidSchema.optional(),
+	organizationId: cuidSchema,
+	createdAt: datetimeSchema,
+	updatedAt: datetimeSchema,
+	status: runStatusSchema,
+	runtimeVersion: runtimeVersionSchema,
+	expertKey: expertKeyFieldSchema,
+	interactiveToolCallResult: z.boolean().optional(),
+	expert: expertWithMetadataSchema,
+	stepNumber: z.number().int().min(0),
+	usage: usageSchema,
+	machineId: z.string().optional()
+});
+
+//#endregion
+//#region src/lib/errors.ts
+function createValidationError(error) {
+	return {
+		code: 400,
+		message: `Validation failed: ${error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")}`,
+		reason: error.issues
+	};
+}
+function createAbortError() {
+	return {
+		code: 0,
+		message: "Request aborted",
+		aborted: true
+	};
+}
+function createNetworkError(error) {
+	return {
+		code: 0,
+		message: error instanceof Error ? error.message : "Network error",
+		reason: error
+	};
+}
+function createHttpError(status, statusText, body) {
+	if (typeof body === "object" && body !== null) {
+		const hasReason = "reason" in body;
+		if ("error" in body && typeof body.error === "string") return {
+			code: status,
+			message: body.error,
+			reason: hasReason ? body.reason : void 0
+		};
+		if (hasReason) return {
+			code: status,
+			message: statusText,
+			reason: body.reason
+		};
+	}
+	return {
+		code: status,
+		message: statusText
+	};
+}
+
+//#endregion
+//#region src/endpoints/applications.ts
+const BASE_PATH$4 = "/api/v1/applications";
+function buildQueryString$4(params) {
+	if (!params) return "";
+	const searchParams = new URLSearchParams();
+	if (params.name !== void 0) searchParams.set("name", params.name);
+	if (params.sort !== void 0) searchParams.set("sort", params.sort);
+	if (params.order !== void 0) searchParams.set("order", params.order);
+	if (params.take !== void 0) searchParams.set("take", params.take.toString());
+	if (params.skip !== void 0) searchParams.set("skip", params.skip.toString());
+	const queryString = searchParams.toString();
+	return queryString ? `?${queryString}` : "";
+}
+function createApplicationsApi(fetcher) {
+	return {
+		async list(params, options) {
+			if (params) {
+				const result = request$35.query.safeParse(params);
+				if (!result.success) return {
+					ok: false,
+					error: createValidationError(result.error)
+				};
+			}
+			const queryString = buildQueryString$4(params);
+			return fetcher.get(`${BASE_PATH$4}${queryString}`, options);
+		},
+		async get(id, options) {
+			return fetcher.get(`${BASE_PATH$4}/${id}`, options);
+		},
+		async create(input, options) {
+			const result = request$38.body.safeParse(input);
+			if (!result.success) return {
+				ok: false,
+				error: createValidationError(result.error)
+			};
+			return fetcher.post(BASE_PATH$4, input, options);
+		},
+		async update(id, input, options) {
+			const result = request$34.body.safeParse(input);
+			if (!result.success) return {
+				ok: false,
+				error: createValidationError(result.error)
+			};
+			return fetcher.post(`${BASE_PATH$4}/${id}`, input, options);
+		},
+		async delete(id, options) {
+			return fetcher.delete(`${BASE_PATH$4}/${id}`, options);
+		}
+	};
+}
+
+//#endregion
+//#region src/endpoints/env-secrets.ts
+const BASE_PATH$3 = "/api/v1/env/secrets";
+function createSecretsApi(fetcher) {
+	return {
+		async list(options) {
+			return fetcher.get(BASE_PATH$3, options);
+		},
+		async get(name, options) {
+			const encodedName = encodeURIComponent(name);
+			return fetcher.get(`${BASE_PATH$3}/${encodedName}`, options);
+		},
+		async create(input, options) {
+			const result = request$33.body.safeParse(input);
+			if (!result.success) return {
+				ok: false,
+				error: createValidationError(result.error)
+			};
+			return fetcher.post(BASE_PATH$3, input, options);
+		},
+		async update(name, input, options) {
+			const result = request$29.body.safeParse(input);
+			if (!result.success) return {
+				ok: false,
+				error: createValidationError(result.error)
+			};
+			const encodedName = encodeURIComponent(name);
+			return fetcher.put(`${BASE_PATH$3}/${encodedName}`, input, options);
+		},
+		async delete(name, options) {
+			const encodedName = encodeURIComponent(name);
+			return fetcher.deleteNoContent(`${BASE_PATH$3}/${encodedName}`, options);
+		}
+	};
+}
+
+//#endregion
+//#region src/endpoints/env-variables.ts
+const BASE_PATH$2 = "/api/v1/env/variables";
+function createVariablesApi(fetcher) {
+	return {
+		async list(options) {
+			return fetcher.get(BASE_PATH$2, options);
+		},
+		async get(name, options) {
+			const encodedName = encodeURIComponent(name);
+			return fetcher.get(`${BASE_PATH$2}/${encodedName}`, options);
+		},
+		async create(input, options) {
+			const result = request$28.body.safeParse(input);
+			if (!result.success) return {
+				ok: false,
+				error: createValidationError(result.error)
+			};
+			return fetcher.post(BASE_PATH$2, input, options);
+		},
+		async update(name, input, options) {
+			const result = request$24.body.safeParse(input);
+			if (!result.success) return {
+				ok: false,
+				error: createValidationError(result.error)
+			};
+			const encodedName = encodeURIComponent(name);
+			return fetcher.put(`${BASE_PATH$2}/${encodedName}`, input, options);
+		},
+		async delete(name, options) {
+			const encodedName = encodeURIComponent(name);
+			return fetcher.deleteNoContent(`${BASE_PATH$2}/${encodedName}`, options);
+		}
+	};
+}
+
+//#endregion
+//#region src/endpoints/env.ts
+function createEnvApi(fetcher) {
+	return {
+		secrets: createSecretsApi(fetcher),
+		variables: createVariablesApi(fetcher)
+	};
+}
+
+//#endregion
+//#region src/endpoints/experts-drafts.ts
+function buildQueryString$3(params) {
+	if (!params) return "";
+	const searchParams = new URLSearchParams();
+	if (params.limit !== void 0) searchParams.set("limit", params.limit.toString());
+	if (params.offset !== void 0) searchParams.set("offset", params.offset.toString());
+	const queryString = searchParams.toString();
+	return queryString ? `?${queryString}` : "";
+}
+function createDraftsApi(fetcher, basePath) {
+	return {
+		async list(scopeName, params, options) {
+			if (params) {
+				const result = request$19.query.safeParse(params);
+				if (!result.success) return {
+					ok: false,
+					error: createValidationError(result.error)
+				};
+			}
+			const encodedScopeName = encodeURIComponent(scopeName);
+			const queryString = buildQueryString$3(params);
+			return fetcher.get(`${basePath}/${encodedScopeName}/drafts${queryString}`, options);
+		},
+		async get(scopeName, draftRef, options) {
+			const encodedScopeName = encodeURIComponent(scopeName);
+			const encodedDraftRef = encodeURIComponent(draftRef);
+			return fetcher.get(`${basePath}/${encodedScopeName}/drafts/${encodedDraftRef}`, options);
+		},
+		async create(scopeName, input, options) {
+			const result = request$22.body.safeParse(input);
+			if (!result.success) return {
+				ok: false,
+				error: createValidationError(result.error)
+			};
+			const encodedScopeName = encodeURIComponent(scopeName);
+			return fetcher.post(`${basePath}/${encodedScopeName}/drafts`, input, options);
+		},
+		async update(scopeName, draftRef, input, options) {
+			const result = request$18.body.safeParse(input);
+			if (!result.success) return {
+				ok: false,
+				error: createValidationError(result.error)
+			};
+			const encodedScopeName = encodeURIComponent(scopeName);
+			const encodedDraftRef = encodeURIComponent(draftRef);
+			return fetcher.post(`${basePath}/${encodedScopeName}/drafts/${encodedDraftRef}`, input, options);
+		},
+		async delete(scopeName, draftRef, options) {
+			const encodedScopeName = encodeURIComponent(scopeName);
+			const encodedDraftRef = encodeURIComponent(draftRef);
+			return fetcher.delete(`${basePath}/${encodedScopeName}/drafts/${encodedDraftRef}`, options);
+		},
+		async assignVersion(scopeName, draftRef, input, options) {
+			const result = request$17.body.safeParse(input);
+			if (!result.success) return {
+				ok: false,
+				error: createValidationError(result.error)
+			};
+			const encodedScopeName = encodeURIComponent(scopeName);
+			const encodedDraftRef = encodeURIComponent(draftRef);
+			return fetcher.post(`${basePath}/${encodedScopeName}/drafts/${encodedDraftRef}/version`, input, options);
+		}
+	};
+}
+
+//#endregion
+//#region src/endpoints/experts-versions.ts
+function createVersionsApi(fetcher, basePath) {
+	return { async list(scopeName, options) {
+		const encodedScopeName = encodeURIComponent(scopeName);
+		return fetcher.get(`${basePath}/${encodedScopeName}/versions`, options);
+	} };
+}
+
+//#endregion
+//#region src/endpoints/experts.ts
+const BASE_PATH$1 = "/api/v1/experts";
+function buildQueryString$2(params) {
+	if (!params) return "";
+	const searchParams = new URLSearchParams();
+	if (params.filter !== void 0) searchParams.set("filter", params.filter);
+	if (params.category !== void 0) searchParams.set("category", params.category);
+	if (params.includeDrafts !== void 0) searchParams.set("includeDrafts", params.includeDrafts.toString());
+	if (params.limit !== void 0) searchParams.set("limit", params.limit.toString());
+	if (params.offset !== void 0) searchParams.set("offset", params.offset.toString());
+	const queryString = searchParams.toString();
+	return queryString ? `?${queryString}` : "";
+}
+function createExpertsApi(fetcher) {
+	return {
+		async list(params, options) {
+			if (params) {
+				const result = request$15.query.safeParse(params);
+				if (!result.success) return {
+					ok: false,
+					error: createValidationError(result.error)
+				};
+			}
+			const queryString = buildQueryString$2(params);
+			return fetcher.get(`${BASE_PATH$1}${queryString}`, options);
+		},
+		async get(key, options) {
+			const encodedKey = encodeURIComponent(key);
+			return fetcher.get(`${BASE_PATH$1}/${encodedKey}`, options);
+		},
+		async getFeatured(options) {
+			return fetcher.get(`${BASE_PATH$1}/featured`, options);
+		},
+		async getMeta(key, options) {
+			const encodedKey = encodeURIComponent(key);
+			return fetcher.get(`${BASE_PATH$1}/${encodedKey}/meta`, options);
+		},
+		async publish(scopeName, options) {
+			const encodedScopeName = encodeURIComponent(scopeName);
+			return fetcher.post(`${BASE_PATH$1}/${encodedScopeName}/publish`, {}, options);
+		},
+		async unpublish(scopeName, options) {
+			const encodedScopeName = encodeURIComponent(scopeName);
+			return fetcher.post(`${BASE_PATH$1}/${encodedScopeName}/unpublish`, {}, options);
+		},
+		async yank(key, options) {
+			const encodedKey = encodeURIComponent(key);
+			return fetcher.delete(`${BASE_PATH$1}/${encodedKey}`, options);
+		},
+		drafts: createDraftsApi(fetcher, BASE_PATH$1),
+		versions: createVersionsApi(fetcher, BASE_PATH$1)
+	};
+}
+
+//#endregion
+//#region src/lib/sse.ts
+async function* parseSSE(reader) {
+	const decoder = new TextDecoder();
+	let buffer = "";
+	while (true) {
+		const { value, done } = await reader.read();
+		if (done) break;
+		buffer += decoder.decode(value, { stream: true });
+		const events = buffer.split("\n\n");
+		buffer = events.pop() || "";
+		for (const event of events) {
+			if (event.trim() === "") continue;
+			const lines = event.split("\n");
+			const eventType = lines.find((line) => line.startsWith("event:"))?.slice(6).trim();
+			const data = lines.find((line) => line.startsWith("data:"))?.slice(5).trim();
+			if (eventType !== "message" || !data) continue;
+			try {
+				yield JSON.parse(data);
+			} catch {}
+		}
+	}
+}
+
+//#endregion
+//#region src/endpoints/jobs-checkpoints.ts
+function buildQueryString$1(params) {
+	if (!params) return "";
+	const searchParams = new URLSearchParams();
+	if (params.take !== void 0) searchParams.set("take", params.take.toString());
+	if (params.skip !== void 0) searchParams.set("skip", params.skip.toString());
+	if (params.sort !== void 0) searchParams.set("sort", params.sort);
+	if (params.order !== void 0) searchParams.set("order", params.order);
+	const queryString = searchParams.toString();
+	return queryString ? `?${queryString}` : "";
+}
+function createCheckpointsApi(fetcher, basePath) {
+	return {
+		async list(jobId, params, options) {
+			if (params) {
+				const result = request$8.query.safeParse(params);
+				if (!result.success) return {
+					ok: false,
+					error: createValidationError(result.error)
+				};
+			}
+			const queryString = buildQueryString$1(params);
+			return fetcher.get(`${basePath}/${jobId}/checkpoints${queryString}`, options);
+		},
+		async get(jobId, checkpointId, options) {
+			return fetcher.get(`${basePath}/${jobId}/checkpoints/${checkpointId}`, options);
+		},
+		async create(jobId, input, options) {
+			const result = request$10.body.safeParse(input);
+			if (!result.success) return {
+				ok: false,
+				error: createValidationError(result.error)
+			};
+			return fetcher.post(`${basePath}/${jobId}/checkpoints`, input, options);
+		},
+		async *stream(jobId, options) {
+			const result = await fetcher.getStream(`${basePath}/${jobId}/checkpoints/stream`, options);
+			if (!result.ok) throw new Error(`Failed to start checkpoint stream: ${result.error.message}`);
+			const reader = result.data.getReader();
+			for await (const checkpoint of parseSSE(reader)) yield checkpoint;
+		}
+	};
+}
+
+//#endregion
+//#region src/endpoints/jobs-workspace.ts
+function buildTreeQueryString(params) {
+	if (!params) return "";
+	const searchParams = new URLSearchParams();
+	if (params.path !== void 0) searchParams.set("path", params.path);
+	if (params.recursive !== void 0) searchParams.set("recursive", params.recursive.toString());
+	const queryString = searchParams.toString();
+	return queryString ? `?${queryString}` : "";
+}
+function createWorkspaceApi(fetcher, basePath) {
+	return {
+		async get(jobId, options) {
+			return fetcher.get(`${basePath}/${jobId}/workspace`, options);
+		},
+		async tree(jobId, params, options) {
+			if (params) {
+				const result = request.query.safeParse(params);
+				if (!result.success) return {
+					ok: false,
+					error: createValidationError(result.error)
+				};
+			}
+			const queryString = buildTreeQueryString(params);
+			return fetcher.get(`${basePath}/${jobId}/workspace/tree${queryString}`, options);
+		},
+		async blob(jobId, path, options) {
+			const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
+			return fetcher.getBlob(`${basePath}/${jobId}/workspace/blob/${normalizedPath}`, options);
+		}
+	};
+}
+
+//#endregion
+//#region src/endpoints/jobs.ts
+const BASE_PATH = "/api/v1/jobs";
+function buildQueryString(params) {
+	if (!params) return "";
+	const searchParams = new URLSearchParams();
+	if (params.take !== void 0) searchParams.set("take", params.take.toString());
+	if (params.skip !== void 0) searchParams.set("skip", params.skip.toString());
+	if (params.sort !== void 0) searchParams.set("sort", params.sort);
+	if (params.order !== void 0) searchParams.set("order", params.order);
+	const queryString = searchParams.toString();
+	return queryString ? `?${queryString}` : "";
+}
+function createJobsApi(fetcher) {
+	return {
+		async list(params, options) {
+			if (params) {
+				const result = request$3.query.safeParse(params);
+				if (!result.success) return {
+					ok: false,
+					error: createValidationError(result.error)
+				};
+			}
+			const queryString = buildQueryString(params);
+			return fetcher.get(`${BASE_PATH}${queryString}`, options);
+		},
+		async get(id, options) {
+			return fetcher.get(`${BASE_PATH}/${id}`, options);
+		},
+		async start(input, options) {
+			const result = request$5.body.safeParse(input);
+			if (!result.success) return {
+				ok: false,
+				error: createValidationError(result.error)
+			};
+			return fetcher.post(BASE_PATH, input, options);
+		},
+		async update(id, input, options) {
+			const result = request$2.body.safeParse(input);
+			if (!result.success) return {
+				ok: false,
+				error: createValidationError(result.error)
+			};
+			return fetcher.post(`${BASE_PATH}/${id}`, input, options);
+		},
+		async continue(id, input, options) {
+			const result = request$6.body.safeParse(input);
+			if (!result.success) return {
+				ok: false,
+				error: createValidationError(result.error)
+			};
+			return fetcher.post(`${BASE_PATH}/${id}/continue`, input, options);
+		},
+		async cancel(id, options) {
+			return fetcher.post(`${BASE_PATH}/${id}/cancel`, {}, options);
+		},
+		checkpoints: createCheckpointsApi(fetcher, BASE_PATH),
+		workspace: createWorkspaceApi(fetcher, BASE_PATH)
+	};
+}
+
+//#endregion
+//#region src/lib/fetcher.ts
+const DEFAULT_BASE_URL = "https://api.perstack.ai";
+const DEFAULT_TIMEOUT = 3e4;
+function createFetcher(config) {
+	const baseUrl = config.baseUrl ?? DEFAULT_BASE_URL;
+	const timeout = config.timeout ?? DEFAULT_TIMEOUT;
+	const useCredentials = "credentials" in config && config.credentials === "include";
+	const apiKey = "apiKey" in config ? config.apiKey : void 0;
+	function buildUrl(path) {
+		return `${baseUrl}${path}`;
+	}
+	function buildHeaders() {
+		const headers = { "Content-Type": "application/json" };
+		if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+		return headers;
+	}
+	function getCredentials() {
+		return useCredentials ? "include" : void 0;
+	}
+	function createTimeoutSignal(externalSignal) {
+		const controller = new AbortController();
+		const timeoutId = setTimeout(() => controller.abort(), timeout);
+		let abortHandler;
+		if (externalSignal) if (externalSignal.aborted) controller.abort();
+		else {
+			abortHandler = () => controller.abort();
+			externalSignal.addEventListener("abort", abortHandler);
+		}
+		return {
+			signal: controller.signal,
+			cleanup: () => {
+				clearTimeout(timeoutId);
+				if (abortHandler && externalSignal) externalSignal.removeEventListener("abort", abortHandler);
+			}
+		};
+	}
+	async function request$39(method, path, body, options) {
+		const { signal, cleanup } = createTimeoutSignal(options?.signal);
+		try {
+			const response$41 = await fetch(buildUrl(path), {
+				method,
+				headers: buildHeaders(),
+				body: body ? JSON.stringify(body) : void 0,
+				signal,
+				credentials: getCredentials()
+			});
+			if (!response$41.ok) {
+				let errorBody;
+				try {
+					errorBody = await response$41.json();
+				} catch {
+					errorBody = void 0;
+				}
+				return {
+					ok: false,
+					error: createHttpError(response$41.status, response$41.statusText, errorBody)
+				};
+			}
+			return {
+				ok: true,
+				data: await response$41.json()
+			};
+		} catch (error) {
+			if (error instanceof Error && error.name === "AbortError") return {
+				ok: false,
+				error: createAbortError()
+			};
+			return {
+				ok: false,
+				error: createNetworkError(error)
+			};
+		} finally {
+			cleanup();
+		}
+	}
+	async function requestBlob(path, options) {
+		const { signal, cleanup } = createTimeoutSignal(options?.signal);
+		try {
+			const response$41 = await fetch(buildUrl(path), {
+				method: "GET",
+				headers: buildHeaders(),
+				signal,
+				credentials: getCredentials()
+			});
+			if (!response$41.ok) {
+				let errorBody;
+				try {
+					errorBody = await response$41.json();
+				} catch {
+					errorBody = void 0;
+				}
+				return {
+					ok: false,
+					error: createHttpError(response$41.status, response$41.statusText, errorBody)
+				};
+			}
+			return {
+				ok: true,
+				data: await response$41.blob()
+			};
+		} catch (error) {
+			if (error instanceof Error && error.name === "AbortError") return {
+				ok: false,
+				error: createAbortError()
+			};
+			return {
+				ok: false,
+				error: createNetworkError(error)
+			};
+		} finally {
+			cleanup();
+		}
+	}
+	async function requestStream(path, options) {
+		const { signal, cleanup } = createTimeoutSignal(options?.signal);
+		try {
+			const response$41 = await fetch(buildUrl(path), {
+				method: "GET",
+				headers: buildHeaders(),
+				signal,
+				credentials: getCredentials()
+			});
+			if (!response$41.ok) {
+				let errorBody;
+				try {
+					errorBody = await response$41.json();
+				} catch {
+					errorBody = void 0;
+				}
+				cleanup();
+				return {
+					ok: false,
+					error: createHttpError(response$41.status, response$41.statusText, errorBody)
+				};
+			}
+			if (!response$41.body) {
+				cleanup();
+				return {
+					ok: false,
+					error: createNetworkError(/* @__PURE__ */ new Error("Response body is null"))
+				};
+			}
+			cleanup();
+			return {
+				ok: true,
+				data: response$41.body
+			};
+		} catch (error) {
+			cleanup();
+			if (error instanceof Error && error.name === "AbortError") return {
+				ok: false,
+				error: createAbortError()
+			};
+			return {
+				ok: false,
+				error: createNetworkError(error)
+			};
+		}
+	}
+	async function requestNoContent(method, path, options) {
+		const { signal, cleanup } = createTimeoutSignal(options?.signal);
+		try {
+			const response$41 = await fetch(buildUrl(path), {
+				method,
+				headers: buildHeaders(),
+				signal,
+				credentials: getCredentials()
+			});
+			if (!response$41.ok) {
+				let errorBody;
+				try {
+					errorBody = await response$41.json();
+				} catch {
+					errorBody = void 0;
+				}
+				return {
+					ok: false,
+					error: createHttpError(response$41.status, response$41.statusText, errorBody)
+				};
+			}
+			return {
+				ok: true,
+				data: void 0
+			};
+		} catch (error) {
+			if (error instanceof Error && error.name === "AbortError") return {
+				ok: false,
+				error: createAbortError()
+			};
+			return {
+				ok: false,
+				error: createNetworkError(error)
+			};
+		} finally {
+			cleanup();
+		}
+	}
+	return {
+		get: (path, options) => request$39("GET", path, void 0, options),
+		post: (path, body, options) => request$39("POST", path, body, options),
+		put: (path, body, options) => request$39("PUT", path, body, options),
+		delete: (path, options) => request$39("DELETE", path, void 0, options),
+		deleteNoContent: (path, options) => requestNoContent("DELETE", path, options),
+		getBlob: (path, options) => requestBlob(path, options),
+		getStream: (path, options) => requestStream(path, options)
+	};
+}
+
+//#endregion
+//#region src/client.ts
+function createApiClient(config) {
+	const fetcher = createFetcher(config);
+	return {
+		applications: createApplicationsApi(fetcher),
+		env: createEnvApi(fetcher),
+		jobs: createJobsApi(fetcher),
+		experts: createExpertsApi(fetcher)
+	};
+}
+
+//#endregion
+//#region src/lib/api-key.ts
+function matchWildcard(value, pattern) {
+	if (pattern === "*") return true;
+	if (pattern.endsWith("*")) return value.startsWith(pattern.slice(0, -1));
+	if (pattern.startsWith("*")) return value.endsWith(pattern.slice(1));
+	return value === pattern;
+}
+function matchOperations(operations, requiredOperation) {
+	return operations.some((pattern) => matchWildcard(requiredOperation, pattern));
+}
+function matchExperts(experts, expertId) {
+	if (experts === void 0 || experts === "*") return true;
+	return experts.some((pattern) => matchWildcard(expertId, pattern));
+}
+function isApiKeyPermissions(parsed) {
+	return typeof parsed === "object" && parsed !== null && "operations" in parsed && Array.isArray(parsed.operations);
+}
+function parseApiKeyPermissions(permissionsJson) {
+	if (!permissionsJson) return null;
+	try {
+		const parsed = JSON.parse(permissionsJson);
+		if (!isApiKeyPermissions(parsed)) return null;
+		return parsed;
+	} catch {
+		return null;
+	}
+}
+function stringifyApiKeyPermissions(permissions) {
+	return JSON.stringify(permissions);
+}
+
+//#endregion
+//#region src/lib/auth.ts
+/**
+* Build authentication headers from AuthOptions.
+*/
+function buildAuthHeaders(auth) {
+	if (auth.type === "apiKey") return { Authorization: `Bearer ${auth.apiKey}` };
+	return { Cookie: auth.cookie };
+}
+
+//#endregion
+export { buildAuthHeaders, createAbortError, createApiClient, createFetcher, createHttpError, createNetworkError, createValidationError, matchExperts, matchOperations, matchWildcard, parseApiKeyPermissions, parseSSE, stringifyApiKeyPermissions };
+//# sourceMappingURL=index.mjs.map