@usepipr/sdk 0.1.3 → 0.2.0

package/dist/index.mjs

@@ -1,2 +1,629 @@
-import { a as schema, c as parseReviewResult, d as reviewResultSchema, f as reviewSchemaExample, i as jsonSchema, l as parseReviewSummary, m as md, n as definePipr, o as schemas, p as reviewSummarySchema, r as definePlugin, s as parseReviewFinding, t as z, u as reviewFindingSchema } from "./src-CR3NktDT.mjs";
+import { i as assertSupportedCommandRestCapture, n as builtinReadOnlyToolBrand, r as configFactoryBrand, t as renderPromptValue } from "./prompt-render-BWiLG-qu.mjs";
+import { z, z as z$1 } from "zod";
+//#region src/prompt.ts
+/** Creates trimmed Markdown from a template literal with common indentation removed. */
+function md(strings, ...values) {
+	let text = "";
+	for (let index = 0; index < strings.length; index += 1) {
+		text += strings[index] ?? "";
+		if (index < values.length) text += String(values[index] ?? "");
+	}
+	return stripCommonIndent(text).trim();
+}
+/** Removes common leading indentation from multiline text. */
+function stripCommonIndent(value) {
+	const lines = value.replaceAll("	", "  ").split(/\r?\n/);
+	const nonEmpty = lines.filter((line) => line.trim().length > 0);
+	const indent = Math.min(...nonEmpty.map((line) => line.match(/^ */)?.[0].length ?? 0));
+	return lines.map((line) => line.slice(indent)).join("\n");
+}
+//#endregion
+//#region src/review-contract.ts
+const nonEmptyStringSchema = z$1.string().min(1);
+const positiveIntegerSchema = z$1.number().int().positive();
+/** Zod schema for a review summary. */
+const reviewSummarySchema = z$1.strictObject({
+	title: nonEmptyStringSchema.optional(),
+	body: nonEmptyStringSchema
+});
+/** Zod schema for one inline review finding. */
+const reviewFindingSchema = z$1.strictObject({
+	body: nonEmptyStringSchema,
+	path: nonEmptyStringSchema,
+	rangeId: nonEmptyStringSchema,
+	side: z$1.enum(["RIGHT", "LEFT"]),
+	startLine: positiveIntegerSchema,
+	endLine: positiveIntegerSchema,
+	suggestedFix: nonEmptyStringSchema.optional()
+});
+/** Zod schema for pipr's core pull request review result. */
+const reviewResultSchema = z$1.strictObject({
+	summary: reviewSummarySchema,
+	inlineFindings: z$1.array(reviewFindingSchema)
+});
+/** Parses model output for pipr's main pull request review schema. */
+function parseReviewResult(value) {
+	return reviewResultSchema.parse(value);
+}
+/** Parses a review summary value. */
+function parseReviewSummary(value) {
+	return reviewSummarySchema.parse(value);
+}
+/** Parses one inline review finding. */
+function parseReviewFinding(value) {
+	return reviewFindingSchema.parse(value);
+}
+/** Returns a small valid example for the main pull request review schema. */
+function reviewSchemaExample() {
+	return {
+		summary: {
+			title: "Optional concise review title.",
+			body: "Concise pull request review summary."
+		},
+		inlineFindings: [{
+			body: "Specific issue and why it matters.",
+			path: "src/example.ts",
+			rangeId: "rng_example",
+			side: "RIGHT",
+			startLine: 1,
+			endLine: 1,
+			suggestedFix: "return safeValue;"
+		}]
+	};
+}
+//#endregion
+//#region src/schema.ts
+const coreReviewOutputSchemaId = "core/pr-review";
+/** Defines a typed schema from a Zod schema. */
+function schema(definition) {
+	if (!definition || typeof definition.id !== "string") throw new Error("pipr.schema requires { id, schema }");
+	assertUserSchemaId(definition.id);
+	return createZodSchema(definition.id, definition.schema);
+}
+/** Defines a typed schema from JSON Schema. The generic type is caller supplied. */
+function jsonSchema(definition) {
+	if (!definition || typeof definition.id !== "string") throw new Error("pipr.jsonSchema requires { id, schema }");
+	assertUserSchemaId(definition.id);
+	const zodSchema = z$1.fromJSONSchema(definition.schema);
+	return createSchema(definition.id, (value) => zodSchema.parse(value), definition.schema);
+}
+/** Built-in schemas available as reusable agent output contracts. */
+const schemas = {
+	review: createZodSchema(coreReviewOutputSchemaId, reviewResultSchema),
+	summary: createZodSchema("core/summary", reviewSummarySchema)
+};
+function createSchema(id, parseValue, schemaJson) {
+	return {
+		kind: "pipr.schema",
+		id,
+		jsonSchema: schemaJson,
+		parse(value) {
+			return parseValue(value);
+		},
+		safeParse(value) {
+			try {
+				return {
+					success: true,
+					data: parseValue(value)
+				};
+			} catch (error) {
+				return {
+					success: false,
+					error: error instanceof Error ? error : new Error(String(error))
+				};
+			}
+		}
+	};
+}
+function createZodSchema(id, zodSchema) {
+	return createSchema(id, (value) => zodSchema.parse(value), jsonSchemaFromZod(id, zodSchema));
+}
+function assertUserSchemaId(id) {
+	if (id.startsWith("core/")) throw new Error(`Schema id '${id}' uses the reserved core/ namespace`);
+}
+function jsonSchemaFromZod(id, schemaDefinition) {
+	try {
+		return z$1.toJSONSchema(schemaDefinition);
+	} catch (error) {
+		const detail = error instanceof Error ? error.message : String(error);
+		throw new Error(`Schema '${id}' could not be converted to JSON Schema. Use JSON-Schema-representable Zod or pipr.jsonSchema<T>(). ${detail}`);
+	}
+}
+//#endregion
+//#region src/builder.ts
+/** Defines a synchronous pipr configuration factory. */
+function definePipr(configure) {
+	return {
+		kind: "pipr.config-factory",
+		[configFactoryBrand]: true,
+		build() {
+			const builder = createBuilder();
+			const result = configure(builder.api);
+			if (typeof result === "object" && result !== null && typeof Reflect.get(result, "then") === "function") throw new Error("definePipr configuration callback must be synchronous");
+			return builder.plan();
+		}
+	};
+}
+/** Defines a typed pipr plugin installer. */
+function definePlugin(setup) {
+	return { setup };
+}
+function createBuilder() {
+	const models = [];
+	const agents = [];
+	const tasks = [];
+	const changeRequestTriggers = [];
+	const commands = [];
+	const tools = [];
+	const publication = {};
+	let checks;
+	let limits;
+	const api = {
+		tools: { readOnly: [{
+			kind: "pipr.tool",
+			name: "readOnly",
+			[builtinReadOnlyToolBrand]: true
+		}] },
+		schemas,
+		on: { changeRequest(options) {
+			if (!Array.isArray(options.actions) || !options.task) throw new Error("pipr.on.changeRequest requires { actions, task }");
+			changeRequestTriggers.push({
+				actions: options.actions,
+				task: options.task
+			});
+		} },
+		secret(options) {
+			if (!options || typeof options.name !== "string") throw new Error("pipr.secret requires { name }");
+			if (!/^[A-Z_][A-Z0-9_]*$/.test(options.name)) throw new Error(`Secret '${options.name}' must be an environment variable name`);
+			return {
+				kind: "pipr.secret",
+				name: options.name
+			};
+		},
+		model(options) {
+			if (!options || typeof options.provider !== "string" || typeof options.model !== "string") throw new Error("pipr.model requires { provider, model }");
+			if (!options.provider || !options.model) throw new Error("pipr.model requires provider and model");
+			const profile = {
+				kind: "pipr.model",
+				id: options.id ?? `${options.provider}/${options.model}`,
+				provider: options.provider,
+				model: options.model,
+				apiKey: options.apiKey,
+				options: options.options
+			};
+			models.push(profile);
+			return profile;
+		},
+		agent(definition) {
+			const agent = createAgent(definition);
+			agents.push(agent);
+			return agent;
+		},
+		task(definition) {
+			if (!definition.name || typeof definition.run !== "function") throw new Error("pipr.task requires { name, run }");
+			const task = {
+				kind: "pipr.task",
+				name: definition.name,
+				check: definition.check,
+				...definition.local === false ? { local: false } : {},
+				handler: definition.run
+			};
+			tasks.push(task);
+			return task;
+		},
+		reviewer(options) {
+			return createReviewer(api, options);
+		},
+		review(options) {
+			assertKnownReviewRecipeOptions(options);
+			registerReviewRecipe(api, options);
+		},
+		config(options) {
+			assertKnownPiprConfigOptions(options);
+			mergePublicationConfig(publication, options.publication);
+			checks = mergeConfigField("checks", checks, options.checks);
+			limits = mergeLimits(limits, options.limits);
+		},
+		command(options) {
+			if (typeof options.pattern !== "string" || !options.task) throw new Error("pipr.command requires { pattern, task }");
+			const pattern = options.pattern;
+			const tokens = pattern.trim().split(/\s+/).filter(Boolean);
+			if (tokens.length === 0) throw new Error("Command pattern must not be empty");
+			if (tokens[0] !== "@pipr") throw new Error(`Command pattern '${pattern}' must start with @pipr`);
+			assertSupportedCommandRestCapture(pattern);
+			commands.push({
+				pattern,
+				permission: options.permission ?? "write",
+				description: options.description,
+				parse: options.parse,
+				task: options.task
+			});
+		},
+		use(plugin) {
+			return plugin.setup(api);
+		},
+		tool(definition) {
+			if (definition.name === "readOnly") throw new Error("Tool name 'readOnly' is reserved for pipr built-in tools");
+			const execute = definition.execute;
+			let run = definition.run;
+			if (!run && !execute) throw new Error(`Tool '${definition.name}' must define run`);
+			if (!run) {
+				const executeTool = execute;
+				if (!executeTool) throw new Error(`Tool '${definition.name}' must define run`);
+				run = (options) => executeToolWithRuntimeInput(executeTool, options);
+			}
+			const tool = {
+				kind: "pipr.tool",
+				...definition,
+				run
+			};
+			tools.push(tool);
+			return tool;
+		},
+		schema,
+		jsonSchema,
+		prompt(strings, ...values) {
+			let text = "";
+			for (let index = 0; index < strings.length; index += 1) {
+				text += strings[index] ?? "";
+				if (index < values.length) text += renderPromptValue(values[index]);
+			}
+			return {
+				kind: "pipr.prompt",
+				value: stripCommonIndent(text).trim()
+			};
+		},
+		section(title, value) {
+			return {
+				kind: "pipr.prompt",
+				value: `## ${title}\n\n${renderPromptValue(value)}`
+			};
+		},
+		json(value, options) {
+			const text = JSON.stringify(value, null, options?.pretty === false ? 0 : 2);
+			if (options?.maxCharacters !== void 0 && text.length > options.maxCharacters) throw new Error(`JSON prompt value exceeded ${options.maxCharacters} characters`);
+			return {
+				kind: "pipr.prompt",
+				value: text
+			};
+		}
+	};
+	return {
+		api,
+		plan() {
+			assertUnique(tasks.map((task) => task.name), "task");
+			assertUnique(commands.map((command) => command.pattern), "command");
+			assertModelIdentity(models);
+			return {
+				models,
+				agents,
+				tasks,
+				changeRequestTriggers,
+				commands,
+				tools,
+				publication,
+				checks,
+				limits
+			};
+		}
+	};
+}
+function registerReviewRecipe(api, options) {
+	const id = options.id;
+	registerReviewRecipeEntrypoints(api, createReviewRecipeTask(api, id, options.reviewer ?? createReviewer(api, reviewRecipeReviewerOptions(options, id)), options), options);
+}
+const reviewRecipeOptionKeys = new Set([
+	"id",
+	"entrypoints",
+	"comment",
+	"check",
+	"timeout",
+	"paths",
+	"reviewer",
+	"name",
+	"model",
+	"fallbacks",
+	"instructions",
+	"prompt",
+	"tools"
+]);
+const reviewRecipeEntrypointKeys = new Set(["changeRequest", "command"]);
+const modelProfileConfigSchema = z$1.custom((value) => typeof value === "object" && value !== null && value.kind === "pipr.model" && typeof value.id === "string" && typeof value.provider === "string" && typeof value.model === "string");
+const autoResolveUserRepliesOptionsSchema = z$1.strictObject({
+	enabled: z$1.boolean().optional(),
+	respondWhenStillValid: z$1.boolean().optional(),
+	allowedActors: z$1.enum([
+		"author-or-write",
+		"write",
+		"any"
+	]).optional()
+});
+const autoResolveOptionsSchema = z$1.union([z$1.literal(false), z$1.strictObject({
+	enabled: z$1.boolean().optional(),
+	model: modelProfileConfigSchema.optional(),
+	instructions: z$1.string().min(1).max(4e3).optional(),
+	synchronize: z$1.boolean().optional(),
+	userReplies: z$1.union([z$1.boolean(), autoResolveUserRepliesOptionsSchema]).optional()
+})]);
+const publicationOptionsSchema = z$1.strictObject({
+	maxInlineComments: z$1.number().int().min(0).max(50).optional(),
+	autoResolve: autoResolveOptionsSchema.optional()
+});
+const aggregateCheckOptionsSchema = z$1.union([z$1.literal(false), z$1.strictObject({
+	enabled: z$1.boolean().optional(),
+	name: z$1.string().min(1).optional()
+})]);
+const checksOptionsSchema = z$1.strictObject({ aggregate: aggregateCheckOptionsSchema.optional() });
+const diffManifestLimitsSchema = z$1.strictObject({
+	fullMaxBytes: z$1.number().int().positive().optional(),
+	fullMaxEstimatedTokens: z$1.number().int().positive().optional(),
+	condensedMaxBytes: z$1.number().int().positive().optional(),
+	condensedMaxEstimatedTokens: z$1.number().int().positive().optional(),
+	toolResponseMaxBytes: z$1.number().int().positive().optional()
+});
+const runtimeLimitsSchema = z$1.strictObject({
+	timeoutSeconds: z$1.number().int().positive().max(3600).optional(),
+	diffManifest: diffManifestLimitsSchema.optional()
+});
+const piprConfigOptionsSchema = z$1.strictObject({
+	publication: publicationOptionsSchema.optional(),
+	checks: checksOptionsSchema.optional(),
+	limits: runtimeLimitsSchema.optional()
+});
+function assertKnownReviewRecipeOptions(options) {
+	const unknownKeys = Object.keys(options).filter((key) => !reviewRecipeOptionKeys.has(key));
+	if (unknownKeys.length > 0) throw new Error(`pipr.review received unsupported option fields: ${unknownKeys.join(", ")}.`);
+	const entrypoints = options.entrypoints;
+	if (entrypoints && typeof entrypoints === "object") {
+		const unknownEntrypointKeys = Object.keys(entrypoints).filter((key) => !reviewRecipeEntrypointKeys.has(key));
+		if (unknownEntrypointKeys.length > 0) throw new Error(`pipr.review entrypoints received unsupported fields: ${unknownEntrypointKeys.join(", ")}.`);
+	}
+}
+function assertKnownPiprConfigOptions(options) {
+	const parsed = piprConfigOptionsSchema.safeParse(options);
+	if (!parsed.success) throw new Error(formatPiprConfigOptionsError(parsed.error));
+}
+function formatPiprConfigOptionsError(error) {
+	const unsupportedFields = firstUnsupportedConfigFields(error.issues, []);
+	if (unsupportedFields) return `${piprConfigLabel(unsupportedFields.path)} received unsupported option fields: ${unsupportedFields.keys.join(", ")}`;
+	return `pipr.config received invalid option value: ${z$1.prettifyError(error)}`;
+}
+function firstUnsupportedConfigFields(issues, parentPath) {
+	for (const issue of issues) {
+		const path = [...parentPath, ...issue.path];
+		if (issue.code === "unrecognized_keys") return {
+			path,
+			keys: issue.keys
+		};
+		if (issue.code === "invalid_union") for (const branchIssues of issue.errors) {
+			const unsupportedFields = firstUnsupportedConfigFields(branchIssues, path);
+			if (unsupportedFields) return unsupportedFields;
+		}
+	}
+}
+function piprConfigLabel(pathSegments) {
+	const path = pathSegments.join(".");
+	return path ? `pipr.config ${path}` : "pipr.config";
+}
+function reviewRecipeReviewerOptions(options, name) {
+	if (!options.model || !options.instructions) throw new Error("pipr.review requires model and instructions when reviewer is not provided");
+	return {
+		name,
+		model: options.model,
+		fallbacks: options.fallbacks,
+		instructions: options.instructions,
+		prompt: options.prompt,
+		tools: options.tools,
+		timeout: options.timeout
+	};
+}
+function createReviewer(api, options) {
+	return api.agent({
+		name: options.name ?? "reviewer",
+		model: options.model,
+		fallbacks: options.fallbacks,
+		instructions: options.instructions,
+		tools: options.tools ?? api.tools.readOnly,
+		output: api.schemas.review,
+		timeout: options.timeout,
+		prompt: options.prompt ?? (() => api.prompt`
+          Review this change.
+        `)
+	});
+}
+function createReviewRecipeTask(api, id, agent, options) {
+	return api.task({
+		name: id,
+		check: options.check,
+		async run(context) {
+			const manifest = await context.change.diffManifest({
+				compressed: true,
+				paths: options.paths
+			});
+			if (options.paths && manifest.files.length === 0) {
+				context.check.neutral("No changed files matched this review's path scope.");
+				await context.comment({ main: "No changed files matched this review's path scope." });
+				return;
+			}
+			const result = await context.pi.run(agent, {
+				manifest,
+				change: context.change
+			}, {
+				timeout: options.timeout,
+				paths: options.paths
+			});
+			const source = typeof options.comment === "function" ? await options.comment(result, {
+				review: { id },
+				repository: context.repository,
+				change: context.change,
+				platform: context.platform
+			}) : options.comment ?? defaultReviewComment(result);
+			await context.comment(source);
+		}
+	});
+}
+function defaultReviewComment(result) {
+	return {
+		main: defaultReviewMarkdown(result),
+		inlineFindings: result.inlineFindings
+	};
+}
+function defaultReviewMarkdown(result) {
+	const findings = result.inlineFindings.length === 0 ? "No inline findings." : result.inlineFindings.map((finding) => `- ${finding.body}`).join("\n");
+	return `## Summary\n\n${result.summary.body}\n\n## Findings\n\n${findings}`;
+}
+function registerReviewRecipeEntrypoints(api, task, options) {
+	const changeRequest = reviewChangeRequestEntrypoint(options);
+	if (changeRequest) api.on.changeRequest({
+		actions: changeRequest,
+		task
+	});
+	const command = reviewCommandEntrypoint(options);
+	if (command) api.command({
+		pattern: command.pattern,
+		...command.options,
+		task
+	});
+}
+function reviewChangeRequestEntrypoint(options) {
+	const entrypoint = options.entrypoints?.changeRequest;
+	return entrypoint === false ? void 0 : entrypoint ?? [
+		"opened",
+		"updated",
+		"reopened",
+		"ready"
+	];
+}
+function reviewCommandEntrypoint(options) {
+	const entrypoint = options.entrypoints?.command;
+	if (entrypoint === false) return;
+	if (typeof entrypoint === "object") return {
+		pattern: entrypoint.pattern ?? "@pipr review",
+		options: {
+			permission: entrypoint.permission ?? "write",
+			description: entrypoint.description
+		}
+	};
+	return {
+		pattern: entrypoint ?? "@pipr review",
+		options: { permission: "write" }
+	};
+}
+function mergePublicationConfig(target, next) {
+	if (!next) return;
+	if (next.maxInlineComments !== void 0) {
+		if (target.maxInlineComments !== void 0 && target.maxInlineComments !== next.maxInlineComments) throw new Error("pipr.config publication.maxInlineComments conflicts with existing value");
+		target.maxInlineComments = next.maxInlineComments;
+	}
+	if (next.autoResolve !== void 0) {
+		if (target.autoResolve !== void 0 && stableJson(target.autoResolve) !== stableJson(next.autoResolve)) throw new Error("pipr.config publication.autoResolve conflicts with existing value");
+		target.autoResolve = next.autoResolve;
+	}
+}
+function mergeConfigField(name, current, next) {
+	if (next === void 0) return current;
+	if (current !== void 0 && stableJson(current) !== stableJson(next)) throw new Error(`pipr.config ${name} conflicts with existing value`);
+	return next;
+}
+function mergeLimits(current, next) {
+	if (!next) return current;
+	assertRuntimeLimitConflicts(current, next);
+	return {
+		...current,
+		...next,
+		diffManifest: next.diffManifest ?? current?.diffManifest ? {
+			...current?.diffManifest,
+			...next.diffManifest
+		} : void 0
+	};
+}
+function assertRuntimeLimitConflicts(current, next) {
+	const currentRecord = current;
+	for (const [key, value] of Object.entries(next)) {
+		if (key === "diffManifest") continue;
+		if (value !== void 0 && currentRecord?.[key] !== void 0 && stableJson(currentRecord[key]) !== stableJson(value)) throw new Error(`pipr.config limits.${key} conflicts with existing value`);
+	}
+	assertDiffManifestLimitConflicts(current, next);
+}
+function assertDiffManifestLimitConflicts(current, next) {
+	if (current?.diffManifest && next.diffManifest) {
+		for (const [key, value] of Object.entries(next.diffManifest)) if (value !== void 0 && current.diffManifest[key] !== void 0 && current.diffManifest[key] !== value) throw new Error(`pipr.config limits.diffManifest.${key} conflicts with existing value`);
+	}
+}
+function createAgent(definition) {
+	return {
+		kind: "pipr.agent",
+		name: definition.name,
+		definition,
+		extend(patch) {
+			return createAgent({
+				...definition,
+				...patch,
+				instructions: patch.instructions === void 0 ? definition.instructions : {
+					kind: "pipr.prompt",
+					value: `${renderPromptValue(definition.instructions)}\n\n${renderPromptValue(patch.instructions)}`.trim()
+				}
+			});
+		}
+	};
+}
+function assertUnique(values, label) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const value of values) {
+		if (seen.has(value)) throw new Error(`Duplicate ${label} '${value}'`);
+		seen.add(value);
+	}
+}
+function assertModelIdentity(models) {
+	assertNoDuplicateModelConfigs(models);
+	assertUniqueModelIds(models);
+	assertProviderModelAliasesDisambiguated(models);
+}
+function assertNoDuplicateModelConfigs(models) {
+	const effectiveConfigs = /* @__PURE__ */ new Map();
+	for (const model of models) {
+		const effectiveConfig = stableJson({
+			provider: model.provider,
+			model: model.model,
+			apiKeyEnv: model.apiKey?.name,
+			options: model.options
+		});
+		const existingConfigId = effectiveConfigs.get(effectiveConfig);
+		if (existingConfigId) throw new Error(`Duplicate model config for '${model.id}'. Reuse model '${existingConfigId}' instead.`);
+		effectiveConfigs.set(effectiveConfig, model.id);
+	}
+}
+function assertUniqueModelIds(models) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const model of models) {
+		if (ids.has(model.id)) {
+			const providerModel = `${model.provider}/${model.model}`;
+			throw new Error(model.id === providerModel ? `Model '${providerModel}' is configured more than once with different options. Add an explicit id.` : `Duplicate model id '${model.id}'`);
+		}
+		ids.add(model.id);
+	}
+}
+function assertProviderModelAliasesDisambiguated(models) {
+	const providerModels = /* @__PURE__ */ new Map();
+	for (const model of models) {
+		const providerModel = `${model.provider}/${model.model}`;
+		const existingProviderModelId = providerModels.get(providerModel);
+		if (existingProviderModelId && (model.id === providerModel || existingProviderModelId === providerModel)) throw new Error(`Model '${providerModel}' is configured more than once with different options. Add an explicit id.`);
+		providerModels.set(providerModel, model.id);
+	}
+}
+function stableJson(value) {
+	return JSON.stringify(stableJsonValue(value));
+}
+function executeToolWithRuntimeInput(execute, options) {
+	return execute(options.ctx, options.input);
+}
+function stableJsonValue(value) {
+	if (Array.isArray(value)) return value.map(stableJsonValue);
+	if (typeof value === "object" && value !== null) return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== void 0).toSorted(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, stableJsonValue(item)]));
+	return value;
+}
+//#endregion
 export { definePipr, definePlugin, jsonSchema, md, parseReviewFinding, parseReviewResult, parseReviewSummary, reviewFindingSchema, reviewResultSchema, reviewSchemaExample, reviewSummarySchema, schema, schemas, z };
+
+//# sourceMappingURL=index.mjs.map