@velajs/studio-protocol 2.0.0

package/dist/index.js

@@ -0,0 +1,775 @@
+import { z } from "zod";
+//#region src/errors.ts
+/**
+* The closed set of Studio-specific error codes. `const` array + derived union
+* so the compile-time type and any runtime membership check can never drift.
+* Parenthetical statuses document the intended HTTP mapping (the wire carries
+* the concrete status on {@link AdminErrorBody}).
+*/
+const STUDIO_ERROR_CODES = [
+	"STUDIO_DISABLED",
+	"STUDIO_UNAUTHORIZED",
+	"STUDIO_UNKNOWN_OP",
+	"STUDIO_OP_FORBIDDEN",
+	"STUDIO_SUB_TOKEN_INVALID",
+	"STUDIO_RATE_LIMITED",
+	"STUDIO_CONFIRM_REQUIRED",
+	"STUDIO_UNKNOWN_MODEL",
+	"DATA_EDIT_DISABLED",
+	"TIMETRAVEL_UNAVAILABLE",
+	"TIMETRAVEL_SCHEMA_MISMATCH",
+	"FEATURE_UNCONFIGURED"
+];
+//#endregion
+//#region src/capabilities.ts
+/**
+* The closed set of feature keys the UI navigates by. `const` array + derived
+* union so a feature panel can light up iff the app actually wired that package.
+*/
+const STUDIO_FEATURE_KEYS = [
+	"app",
+	"openapi",
+	"data",
+	"timeTravel",
+	"transfer",
+	"auth",
+	"authOrganizations",
+	"queue",
+	"schedule",
+	"flags",
+	"logs",
+	"audit",
+	"live",
+	"presence"
+];
+//#endregion
+//#region src/data.ts
+/**
+* Data-browser wire contract. Model discovery + row access shapes.
+*
+* `StudioFilterOperator` is a compatible subset of `@velajs/crud`'s
+* `FilterOperator` (`crud/packages/core/src/adapter/query-types.ts`), and
+* `StudioPageInfo` is a structural mirror of crud's `PageInfo` (snake_case
+* preserved). Drift guards against the real crud package land in the server
+* package; see the report for mirror source paths.
+*/
+/**
+* Grid filter operators — a subset of crud's `FILTER_OPERATORS`, chosen so every
+* member is assignment-compatible with crud's `FilterOperator`. `const` array +
+* derived union so compile-time type and runtime membership can't drift.
+*/
+const STUDIO_FILTER_OPERATORS = [
+	"eq",
+	"ne",
+	"gt",
+	"gte",
+	"lt",
+	"lte",
+	"in",
+	"nin",
+	"like",
+	"ilike",
+	"null",
+	"between"
+];
+//#endregion
+//#region src/connection.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isLocalPath(value) {
+	return typeof value === "string" && value.startsWith("/") && !value.startsWith("//") && !/[\\\\?#\s]/.test(value);
+}
+function parseStudioConnection(value) {
+	if (!isRecord(value) || value.protocolVersion !== 2 || !isLocalPath(value.routerBasePath) || !isLocalPath(value.adminBasePath) || !isLocalPath(value.apiRequestPath) || typeof value.sessionToken !== "string" || value.sessionToken.length === 0) throw new Error("Invalid Studio connection configuration.");
+	return {
+		protocolVersion: value.protocolVersion,
+		routerBasePath: value.routerBasePath,
+		adminBasePath: value.adminBasePath,
+		apiRequestPath: value.apiRequestPath,
+		sessionToken: value.sessionToken
+	};
+}
+//#endregion
+//#region src/app.ts
+function stringMap(input) {
+	if (input === void 0) return void 0;
+	if (!isRecord(input)) throw new Error("Expected string-valued headers or query parameters.");
+	const result = {};
+	for (const [key, item] of Object.entries(input)) {
+		if (typeof item !== "string") throw new Error("Expected string-valued headers or query parameters.");
+		result[key] = item;
+	}
+	return result;
+}
+/** Validate JSON from the local API explorer before any request can be sent. */
+function parseTryItRequest(value) {
+	if (!isRecord(value) || typeof value.method !== "string" || !/^(GET|HEAD|POST|PUT|PATCH|DELETE|OPTIONS)$/i.test(value.method) || typeof value.path !== "string" || !value.path.startsWith("/") || value.path.startsWith("//") || /[\\\\#\s{}]/.test(value.path)) throw new Error("Expected an HTTP method and a resolved absolute path on the Worker.");
+	return {
+		method: value.method.toUpperCase(),
+		path: value.path,
+		query: stringMap(value.query),
+		headers: stringMap(value.headers),
+		body: value.body
+	};
+}
+function parseTryItResponse(value) {
+	if (!isRecord(value) || typeof value.status !== "number" || !Number.isInteger(value.status) || value.status < 100 || value.status > 599 || !isRecord(value.headers) || !("body" in value)) throw new Error("Invalid API response.");
+	const headers = {};
+	for (const [key, item] of Object.entries(value.headers)) {
+		if (typeof item !== "string") throw new Error("Invalid API response headers.");
+		headers[key] = item;
+	}
+	return {
+		status: value.status,
+		headers,
+		body: value.body
+	};
+}
+//#endregion
+//#region src/ops.ts
+/**
+* Op meta for every op. `as const satisfies` enforces total key coverage while
+* preserving literal types (so `destructive` narrows exactly), which drives the
+* type-level destructive-confirm guard in the tests.
+*/
+const STUDIO_OP_META = {
+	"studio.capabilities": {
+		mode: "read",
+		feature: "app"
+	},
+	"app.routes": {
+		mode: "read",
+		feature: "app"
+	},
+	"app.modules": {
+		mode: "read",
+		feature: "app"
+	},
+	"app.entrypoints": {
+		mode: "read",
+		feature: "app"
+	},
+	"app.openapi": {
+		mode: "read",
+		feature: "openapi"
+	},
+	/** Authorizes a host HTTP request; server gates and audits this operational action. */
+	"api.authorizeTryIt": {
+		mode: "write",
+		feature: "openapi",
+		gate: "opsEditable"
+	},
+	"data.listModels": {
+		mode: "read",
+		feature: "data"
+	},
+	"data.describeModel": {
+		mode: "read",
+		feature: "data"
+	},
+	"data.listRows": {
+		mode: "read",
+		feature: "data"
+	},
+	"data.readRow": {
+		mode: "read",
+		feature: "data"
+	},
+	"data.facets": {
+		mode: "read",
+		feature: "data"
+	},
+	"data.cascadePreview": {
+		mode: "read",
+		feature: "data"
+	},
+	"data.writeRow": {
+		mode: "write",
+		feature: "data",
+		gate: "dataEditable"
+	},
+	"data.deleteRows": {
+		mode: "write",
+		feature: "data",
+		gate: "dataEditable",
+		destructive: true
+	},
+	"data.clearTable": {
+		mode: "write",
+		feature: "data",
+		gate: "dataEditable",
+		destructive: true
+	},
+	"data.generateRows": {
+		mode: "write",
+		feature: "data",
+		gate: "dataEditable"
+	},
+	"timeTravel.capabilities": {
+		mode: "read",
+		feature: "timeTravel"
+	},
+	"timeTravel.currentMark": {
+		mode: "read",
+		feature: "timeTravel"
+	},
+	"timeTravel.markForTime": {
+		mode: "read",
+		feature: "timeTravel"
+	},
+	"timeTravel.listMarks": {
+		mode: "read",
+		feature: "timeTravel"
+	},
+	"timeTravel.preview": {
+		mode: "read",
+		feature: "timeTravel"
+	},
+	"timeTravel.armRestore": {
+		mode: "write",
+		feature: "timeTravel",
+		gate: "timeTravelRestore",
+		destructive: true
+	},
+	"timeTravel.undo": {
+		mode: "write",
+		feature: "timeTravel",
+		gate: "timeTravelRestore",
+		destructive: true
+	},
+	"timeTravel.createSnapshot": {
+		mode: "write",
+		feature: "timeTravel"
+	},
+	"timeTravel.prune": {
+		mode: "write",
+		feature: "timeTravel",
+		gate: "timeTravelRestore",
+		destructive: true
+	},
+	"transfer.export": {
+		mode: "read",
+		feature: "transfer"
+	},
+	"transfer.import": {
+		mode: "write",
+		feature: "transfer",
+		gate: "transferImport",
+		destructive: true
+	},
+	"auth.users": {
+		mode: "read",
+		feature: "auth"
+	},
+	"auth.userDetail": {
+		mode: "read",
+		feature: "auth"
+	},
+	"auth.sessions": {
+		mode: "read",
+		feature: "auth"
+	},
+	"auth.revokeSession": {
+		mode: "write",
+		feature: "auth",
+		gate: "opsEditable"
+	},
+	"auth.organizations": {
+		mode: "read",
+		feature: "authOrganizations"
+	},
+	"queue.list": {
+		mode: "read",
+		feature: "queue"
+	},
+	"queue.depths": {
+		mode: "read",
+		feature: "queue"
+	},
+	"queue.dlq": {
+		mode: "read",
+		feature: "queue"
+	},
+	"queue.send": {
+		mode: "write",
+		feature: "queue",
+		gate: "opsEditable"
+	},
+	"queue.replay": {
+		mode: "write",
+		feature: "queue",
+		gate: "opsEditable"
+	},
+	"schedule.jobs": {
+		mode: "read",
+		feature: "schedule"
+	},
+	"schedule.triggers": {
+		mode: "read",
+		feature: "schedule"
+	},
+	"schedule.runNow": {
+		mode: "write",
+		feature: "schedule",
+		gate: "opsEditable"
+	},
+	"flags.list": {
+		mode: "read",
+		feature: "flags"
+	},
+	"flags.evaluate": {
+		mode: "read",
+		feature: "flags"
+	},
+	"logs.tail": {
+		mode: "read",
+		feature: "logs"
+	},
+	"live.subscriptions": {
+		mode: "read",
+		feature: "live"
+	},
+	"presence.rooms": {
+		mode: "read",
+		feature: "presence"
+	},
+	"audit.tail": {
+		mode: "read",
+		feature: "audit"
+	}
+};
+/**
+* Every op name as a runtime const array. Kept as a literal tuple (via
+* `as const satisfies`) so the exhaustiveness drift guard can compare its
+* element union against `keyof StudioRpcMap` in both directions.
+*/
+const STUDIO_OPS = [
+	"studio.capabilities",
+	"app.routes",
+	"app.modules",
+	"app.entrypoints",
+	"app.openapi",
+	"api.authorizeTryIt",
+	"data.listModels",
+	"data.describeModel",
+	"data.listRows",
+	"data.readRow",
+	"data.facets",
+	"data.cascadePreview",
+	"data.writeRow",
+	"data.deleteRows",
+	"data.clearTable",
+	"data.generateRows",
+	"timeTravel.capabilities",
+	"timeTravel.currentMark",
+	"timeTravel.markForTime",
+	"timeTravel.listMarks",
+	"timeTravel.preview",
+	"timeTravel.armRestore",
+	"timeTravel.undo",
+	"timeTravel.createSnapshot",
+	"timeTravel.prune",
+	"transfer.export",
+	"transfer.import",
+	"auth.users",
+	"auth.userDetail",
+	"auth.sessions",
+	"auth.revokeSession",
+	"auth.organizations",
+	"queue.list",
+	"queue.depths",
+	"queue.dlq",
+	"queue.send",
+	"queue.replay",
+	"schedule.jobs",
+	"schedule.triggers",
+	"schedule.runNow",
+	"flags.list",
+	"flags.evaluate",
+	"logs.tail",
+	"live.subscriptions",
+	"presence.rooms",
+	"audit.tail"
+];
+//#endregion
+//#region src/http.ts
+/**
+* Transport constants shared by the server module, the UI, and the dev host.
+* String literals + one integer version marker; zero runtime dependencies.
+*/
+/** Default reserved prefix the admin surface mounts under. */
+const STUDIO_DEFAULT_PATH = "/_vela/admin";
+/** Unauthenticated health probe suffix (`GET {prefix}/health`). */
+const STUDIO_HEALTH_SUFFIX = "/health";
+/** RPC dispatch suffix (`POST {prefix}/rpc/:op`). */
+const STUDIO_RPC_SUFFIX = "/rpc/";
+/** Ephemeral WS sub-token mint suffix (`POST {prefix}/ws-token`). */
+const STUDIO_WS_TOKEN_SUFFIX = "/ws-token";
+/** Snapshot/transfer export suffix (`GET {prefix}/export`). */
+const STUDIO_EXPORT_SUFFIX = "/export";
+/** The header carrying the master bearer token (`Authorization: Bearer <token>`). */
+const STUDIO_TOKEN_HEADER = "authorization";
+/** The wire protocol version. Bumped only on a breaking envelope change. */
+const STUDIO_PROTOCOL_VERSION = 2;
+//#endregion
+//#region src/responses.ts
+const row = z.record(z.string(), z.unknown());
+const strings = z.array(z.string());
+const timeTravelCapabilities = z.object({
+	markByTime: z.boolean(),
+	list: z.boolean(),
+	undo: z.boolean(),
+	inPlace: z.boolean(),
+	restartRequired: z.boolean(),
+	portableExport: z.boolean(),
+	createOnDemand: z.boolean(),
+	granularity: z.enum([
+		"bookmark",
+		"snapshot",
+		"snapshot+cdc"
+	]),
+	scopeNote: z.string()
+});
+const mark = z.object({
+	id: z.string(),
+	kind: z.enum(["bookmark", "snapshot"]),
+	time: z.number().optional(),
+	label: z.string().optional(),
+	schemaHash: z.string().optional(),
+	sizeBytes: z.number().optional(),
+	tables: strings.optional()
+});
+const restoreOutcome = z.object({
+	restoredTo: z.string(),
+	undoMark: mark.optional(),
+	applied: z.boolean(),
+	restartRequested: z.boolean()
+});
+const user = z.object({
+	id: z.string(),
+	email: z.string(),
+	name: z.string().optional(),
+	emailVerified: z.boolean(),
+	image: z.string().optional(),
+	role: z.string().optional(),
+	banned: z.boolean().optional(),
+	createdAt: z.number()
+});
+const session = z.object({
+	id: z.string(),
+	userId: z.string(),
+	createdAt: z.number(),
+	expiresAt: z.number(),
+	ipAddress: z.string().optional(),
+	userAgent: z.string().optional()
+});
+const organization = z.object({
+	id: z.string(),
+	name: z.string(),
+	slug: z.string().optional(),
+	memberCount: z.number().optional(),
+	createdAt: z.number()
+});
+const flagValue = z.union([
+	z.boolean(),
+	z.string(),
+	z.number(),
+	row,
+	z.array(z.unknown())
+]);
+const deleted = z.object({ deleted: z.number() });
+const acknowledged = z.object({ ok: z.literal(true) });
+/** Every operation must supply a concrete validator for its declared output. */
+const STUDIO_RESPONSE_PARSERS = {
+	"studio.capabilities": z.object({
+		operations: z.array(z.enum(STUDIO_OPS)),
+		features: z.record(z.enum(STUDIO_FEATURE_KEYS), z.boolean()),
+		writes: z.object({
+			dataEditable: z.boolean(),
+			schemaEditable: z.boolean(),
+			opsEditable: z.boolean(),
+			runAsIdentity: z.boolean(),
+			timeTravelRestore: z.boolean(),
+			transferImport: z.boolean()
+		}),
+		timeTravel: timeTravelCapabilities.nullable()
+	}).parse,
+	"app.routes": z.array(z.object({
+		method: z.string(),
+		path: z.string(),
+		handler: z.string(),
+		source: z.enum(["controller", "mounted"])
+	})).parse,
+	"app.modules": z.array(z.object({
+		moduleId: z.string(),
+		imports: strings,
+		isGlobal: z.boolean(),
+		lazy: z.boolean(),
+		providers: strings,
+		exports: strings
+	})).parse,
+	"app.entrypoints": z.array(z.object({
+		kind: z.string(),
+		target: z.string(),
+		meta: z.unknown().optional()
+	})).parse,
+	"app.openapi": z.unknown().parse,
+	"api.authorizeTryIt": z.object({ authorized: z.literal(true) }).parse,
+	"data.listModels": z.array(z.object({
+		name: z.string(),
+		table: z.string(),
+		label: z.string(),
+		capabilities: strings
+	})).parse,
+	"data.describeModel": z.object({
+		name: z.string(),
+		table: z.string(),
+		primaryKeys: strings,
+		columns: z.array(z.object({
+			name: z.string(),
+			type: z.enum([
+				"string",
+				"number",
+				"boolean",
+				"date",
+				"json",
+				"unknown"
+			]),
+			pk: z.boolean(),
+			nullable: z.boolean(),
+			unique: z.boolean(),
+			managed: z.boolean(),
+			fk: z.object({
+				table: z.string(),
+				relation: z.string()
+			}).optional()
+		})),
+		relations: z.array(z.object({
+			name: z.string(),
+			type: z.enum([
+				"hasOne",
+				"hasMany",
+				"belongsTo"
+			]),
+			target: z.string(),
+			foreignKey: z.string(),
+			cascade: z.string().optional()
+		})),
+		flags: z.object({
+			softDelete: z.boolean(),
+			multiTenant: z.boolean(),
+			versioning: z.boolean(),
+			audit: z.boolean()
+		}),
+		supports: z.object({
+			bulkWrites: z.boolean(),
+			facets: z.boolean(),
+			search: z.boolean(),
+			cascade: z.boolean()
+		})
+	}).parse,
+	"data.listRows": z.object({
+		rows: z.array(row),
+		info: z.object({
+			page: z.number(),
+			per_page: z.number(),
+			total_count: z.number().optional(),
+			total_pages: z.number().optional(),
+			has_next_page: z.boolean(),
+			has_prev_page: z.boolean(),
+			next_cursor: z.string().optional()
+		})
+	}).parse,
+	"data.readRow": row.nullable().parse,
+	"data.facets": z.object({ buckets: z.array(z.object({
+		value: z.unknown(),
+		count: z.number()
+	})) }).parse,
+	"data.cascadePreview": z.object({ relations: z.array(z.object({
+		relation: z.string(),
+		target: z.string(),
+		action: z.string(),
+		affected: z.number()
+	})) }).parse,
+	"data.writeRow": row.parse,
+	"data.deleteRows": deleted.parse,
+	"data.clearTable": deleted.parse,
+	"data.generateRows": z.object({ inserted: z.number() }).parse,
+	"timeTravel.capabilities": timeTravelCapabilities.parse,
+	"timeTravel.currentMark": mark.parse,
+	"timeTravel.markForTime": mark.nullable().parse,
+	"timeTravel.listMarks": z.object({
+		marks: z.array(mark),
+		nextCursor: z.string().optional()
+	}).parse,
+	"timeTravel.preview": z.object({
+		target: mark,
+		affectedTables: z.array(z.object({
+			table: z.string(),
+			approxRows: z.number().optional()
+		})),
+		schemaCompatible: z.boolean(),
+		incompatibleTables: strings,
+		undoAvailable: z.boolean(),
+		restartRequired: z.boolean(),
+		confirmToken: z.string(),
+		expiresAt: z.number()
+	}).parse,
+	"timeTravel.armRestore": restoreOutcome.parse,
+	"timeTravel.undo": restoreOutcome.parse,
+	"timeTravel.createSnapshot": mark.parse,
+	"timeTravel.prune": z.object({ pruned: z.number() }).parse,
+	"transfer.export": z.object({ exportUrl: z.string() }).parse,
+	"transfer.import": z.object({
+		imported: z.number(),
+		errors: z.array(z.object({
+			line: z.number(),
+			message: z.string()
+		}))
+	}).parse,
+	"auth.users": z.object({
+		rows: z.array(user),
+		nextCursor: z.string().optional()
+	}).parse,
+	"auth.userDetail": z.object({
+		user,
+		sessions: z.array(session),
+		organizations: z.array(organization)
+	}).parse,
+	"auth.sessions": z.array(session).parse,
+	"auth.revokeSession": acknowledged.parse,
+	"auth.organizations": z.array(organization).parse,
+	"queue.list": z.array(z.object({
+		name: z.string(),
+		kind: z.string(),
+		depth: z.number().optional()
+	})).parse,
+	"queue.depths": z.array(z.object({
+		name: z.string(),
+		depth: z.number(),
+		inFlight: z.number().optional()
+	})).parse,
+	"queue.dlq": z.array(z.object({
+		id: z.string(),
+		queue: z.string(),
+		failedAt: z.number(),
+		attempts: z.number(),
+		error: z.string().optional(),
+		payload: z.unknown().optional()
+	})).parse,
+	"queue.send": z.object({ id: z.string() }).parse,
+	"queue.replay": z.object({ replayed: z.number() }).parse,
+	"schedule.jobs": z.array(z.object({
+		name: z.string(),
+		kind: z.enum(["cron", "interval"]),
+		expression: z.string().optional(),
+		ms: z.number().optional(),
+		lastRun: z.number().optional(),
+		nextRun: z.number().optional()
+	})).parse,
+	"schedule.triggers": z.array(z.object({
+		name: z.string(),
+		cron: z.string(),
+		nextRun: z.number().optional()
+	})).parse,
+	"schedule.runNow": acknowledged.parse,
+	"flags.list": z.array(z.object({
+		key: z.string(),
+		value: flagValue
+	})).parse,
+	"flags.evaluate": z.object({
+		flagKey: z.string(),
+		value: flagValue,
+		reason: z.enum([
+			"STATIC",
+			"DEFAULT",
+			"ERROR"
+		]),
+		errorMessage: z.string().optional()
+	}).parse,
+	"logs.tail": z.array(z.object({
+		ts: z.number(),
+		level: z.enum([
+			"debug",
+			"info",
+			"warn",
+			"error"
+		]),
+		msg: z.string(),
+		source: z.string().optional(),
+		fields: row.optional()
+	})).parse,
+	"live.subscriptions": z.array(z.object({
+		id: z.string(),
+		room: z.string(),
+		tags: strings,
+		connectedAt: z.number(),
+		clientId: z.string().optional()
+	})).parse,
+	"presence.rooms": z.array(z.object({
+		room: z.string(),
+		count: z.number(),
+		members: strings.optional()
+	})).parse,
+	"audit.tail": z.array(z.object({
+		ts: z.number(),
+		op: z.string(),
+		mode: z.enum(["read", "write"]),
+		subject: z.string(),
+		status: z.number(),
+		ms: z.number(),
+		ip: z.string().nullable(),
+		detail: z.object({
+			target: z.string().optional(),
+			summary: z.string().optional(),
+			extra: row.optional()
+		}).optional()
+	})).parse
+};
+/** The result type comes only from the selected operation and its validator. */
+function parseStudioResponse(op, value) {
+	return STUDIO_RESPONSE_PARSERS[op](value);
+}
+const errorStatus = z.number().int().min(400).max(599);
+const envelope = z.discriminatedUnion("ok", [z.object({
+	ok: z.literal(true),
+	op: z.string(),
+	data: z.unknown(),
+	meta: z.object({
+		ms: z.number(),
+		op: z.string(),
+		mode: z.enum(["read", "write"])
+	})
+}), z.object({
+	ok: z.literal(false),
+	op: z.string(),
+	status: errorStatus,
+	error: z.object({
+		code: z.string(),
+		title: z.string(),
+		status: errorStatus,
+		message: z.string(),
+		hint: z.string().optional(),
+		docsUrl: z.string().optional(),
+		details: z.unknown().optional()
+	})
+})]);
+/** Validate the envelope, operation identity, and operation-specific payload. */
+function parseStudioRpcResponse(op, value) {
+	const parsed = envelope.parse(value);
+	if (parsed.op !== op) throw new Error("Studio response operation does not match the request.");
+	if (!parsed.ok) {
+		if (parsed.status !== parsed.error.status) throw new Error("Inconsistent Studio error status.");
+		return parsed;
+	}
+	if (parsed.meta.op !== op || parsed.meta.mode !== STUDIO_OP_META[op].mode) throw new Error("Studio response metadata does not match the request.");
+	return {
+		...parsed,
+		data: parseStudioResponse(op, parsed.data)
+	};
+}
+//#endregion
+export { STUDIO_DEFAULT_PATH, STUDIO_ERROR_CODES, STUDIO_EXPORT_SUFFIX, STUDIO_FEATURE_KEYS, STUDIO_FILTER_OPERATORS, STUDIO_HEALTH_SUFFIX, STUDIO_OPS, STUDIO_OP_META, STUDIO_PROTOCOL_VERSION, STUDIO_RESPONSE_PARSERS, STUDIO_RPC_SUFFIX, STUDIO_TOKEN_HEADER, STUDIO_WS_TOKEN_SUFFIX, isRecord, parseStudioConnection, parseStudioResponse, parseStudioRpcResponse, parseTryItRequest, parseTryItResponse };
+
+//# sourceMappingURL=index.js.map