@andesine/sdk 0.1.0 → 0.5.0

package/dist/index.js

@@ -1,1137 +1,40 @@
-import { i as AndesineStreamProtocolError, n as AndesineAPIError, r as AndesineStreamError, t as createAnswerStream } from "./answer-stream-7N_gLhVS.js";
-import createFetchClient from "openapi-fetch";
-//#region src/paginate.ts
-/**
-* Iterate cursor-paginated pages, retaining their metadata.
-*
-* @param getPage - Fetch one page for the supplied cursor. The first cursor is undefined unless supplied.
-* Keep filters stable. This generic helper does not bind snapshots; use content.paginateEntryPages()
-* or content.paginateCollectionPages() for automatic published snapshot handling.
-* @param options - Optional cursor from an earlier page to resume processing.
-* @returns A lazy iterator that requests the next page only after the previous page is consumed.
-* Save pagination.nextCursor after processing a page. Break the loop to stop further requests.
-* @throws Error for a missing or repeated next cursor. Callback failures pass through unchanged.
-*/
-const paginatePages = async function* (getPage, options = {}) {
-	const seen = new Set(options.cursor ? [options.cursor] : []);
-	let cursor = options.cursor;
-	do {
-		const page = await getPage(cursor);
-		const next = page.pagination.nextCursor;
-		if (page.pagination.hasMore && (!next || seen.has(next))) throw new Error("Pagination returned a missing or repeated cursor");
-		yield page;
-		if (!page.pagination.hasMore) return;
-		seen.add(next);
-		cursor = next;
-	} while (cursor);
-};
-/**
-* Iterate items across cursor-paginated pages without collecting them in memory.
-*
-* @param getPage - Fetch one page using the cursor. Keep scope and filters stable in this callback.
-* This generic helper does not bind snapshots; content.paginateEntries() and
-* content.paginateCollections() do that automatically for published content.
-* @param options - Optional starting cursor; retain its matching scope and snapshot yourself.
-* @returns Items in API order. Break the loop to prevent further page requests.
-* @throws Pagination errors from paginatePages(), or the original callback error.
-*/
-const paginate = async function* (getPage, options = {}) {
-	for await (const page of paginatePages(getPage, options)) yield* page.data;
-};
-//#endregion
-//#region src/content-client.ts
-const paginateSnapshotPages = async function* (list, input, options = {}) {
-	let query = { ...input };
-	yield* paginatePages(async (cursor) => {
-		const page = await list({
-			...query,
-			cursor
-		}, {
-			...options,
-			response: "data"
-		});
-		if (query.snapshotID !== void 0 && page.snapshotID !== query.snapshotID) throw new Error("Pagination returned a different snapshot");
-		query = {
-			...query,
-			channel: void 0,
-			snapshotID: page.snapshotID
-		};
-		return page;
-	}, { cursor: input.cursor });
-};
-const createContentClient = (content) => {
-	const paginateEntryPages = (input = {}, options) => paginateSnapshotPages((query, requestOptions) => content.listEntries(query, requestOptions), input, options);
-	const paginateCollectionPages = (input = {}, options) => paginateSnapshotPages((query, requestOptions) => content.listCollections(query, requestOptions), input, options);
-	return {
-		...content,
-		paginateEntryPages,
-		async *paginateEntries(input, options) {
-			for await (const page of paginateEntryPages(input, options)) yield* page.data;
-		},
-		paginateCollectionPages,
-		async *paginateCollections(input, options) {
-			for await (const page of paginateCollectionPages(input, options)) yield* page.data;
-		}
-	};
-};
-//#endregion
-//#region src/query.ts
-const serializeQuery = (query) => {
-	const parameters = new URLSearchParams();
-	const escapeKey = (key) => key.replace(/[\\[\]]/g, (character) => `\\${character}`);
-	const append = (path, value) => {
-		if (value === void 0 || value === null) return;
-		if (Array.isArray(value)) value.forEach((item, index) => append(`${path}[${index}]`, item));
-		else if (typeof value === "object") for (const [key, item] of Object.entries(value)) append(`${path}[${escapeKey(key)}]`, item);
-		else parameters.append(path, String(value));
-	};
-	for (const [key, value] of Object.entries(query)) append(escapeKey(key), value);
-	return parameters.toString();
-};
-//#endregion
-//#region src/operation.ts
-const operation = (request, definition) => {
-	return ((input, options) => {
-		return request(definition, input || {}, options);
-	});
-};
-//#endregion
-//#region src/generated/resources.ts
-const createResources = (request) => ({
-	assets: {
-		search: operation(request, {
-			method: "get",
-			path: "/assets/search",
-			pathParams: [],
-			queryParams: [
-				"query",
-				"checksum",
-				"semantic",
-				"limit"
-			],
-			body: false,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		importURL: operation(request, {
-			method: "post",
-			path: "/assets/imports",
-			pathParams: [],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		attach: operation(request, {
-			method: "post",
-			path: "/assets/{assetID}/attachments",
-			pathParams: ["assetID"],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		register: operation(request, {
-			method: "post",
-			path: "/assets/uploads",
-			pathParams: [],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		upload: operation(request, {
-			method: "put",
-			path: "/assets/{assetID}/upload",
-			pathParams: ["assetID"],
-			queryParams: [],
-			body: true,
-			multipart: true,
-			binary: false,
-			anonymous: false
-		}),
-		get: operation(request, {
-			method: "get",
-			path: "/assets/{assetID}",
-			pathParams: ["assetID"],
-			queryParams: ["entryID"],
-			body: false,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		})
-	},
-	instance: { get: operation(request, {
-		method: "get",
-		path: "/instance",
-		pathParams: [],
-		queryParams: [],
-		body: false,
-		multipart: false,
-		binary: false,
-		anonymous: false
-	}) },
-	entries: {
-		create: operation(request, {
-			method: "post",
-			path: "/entries",
-			pathParams: [],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		bulkDelete: operation(request, {
-			method: "post",
-			path: "/entries/bulk/delete",
-			pathParams: [],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		delete: operation(request, {
-			method: "delete",
-			path: "/entries/{id}",
-			pathParams: ["id"],
-			queryParams: [],
-			body: false,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		update: operation(request, {
-			method: "put",
-			path: "/entries/{id}",
-			pathParams: ["id"],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		get: operation(request, {
-			method: "get",
-			path: "/entries/get",
-			pathParams: [],
-			queryParams: [
-				"id",
-				"path",
-				"expectedSchemaHash"
-			],
-			body: false,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		list: operation(request, {
-			method: "get",
-			path: "/entries/list",
-			pathParams: [],
-			queryParams: [
-				"collectionID",
-				"collectionPath",
-				"cursor",
-				"limit"
-			],
-			body: false,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		})
-	},
-	collections: {
-		create: operation(request, {
-			method: "post",
-			path: "/collections",
-			pathParams: [],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		bulkDelete: operation(request, {
-			method: "post",
-			path: "/collections/bulk/delete",
-			pathParams: [],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		delete: operation(request, {
-			method: "delete",
-			path: "/collections/{id}",
-			pathParams: ["id"],
-			queryParams: [],
-			body: false,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		update: operation(request, {
-			method: "put",
-			path: "/collections/{id}",
-			pathParams: ["id"],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		list: operation(request, {
-			method: "get",
-			path: "/collections/list",
-			pathParams: [],
-			queryParams: [
-				"collectionID",
-				"collectionPath",
-				"cursor",
-				"limit"
-			],
-			body: false,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		})
-	},
-	content: {
-		listCollections: operation(request, {
-			method: "get",
-			path: "/content/collections",
-			pathParams: [],
-			queryParams: [
-				"cursor",
-				"limit",
-				"collectionID",
-				"collectionPath",
-				"channel",
-				"snapshotID"
-			],
-			body: false,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		listEntries: operation(request, {
-			method: "get",
-			path: "/content/entries",
-			pathParams: [],
-			queryParams: [
-				"cursor",
-				"limit",
-				"collectionID",
-				"collectionPath",
-				"channel",
-				"snapshotID",
-				"descendants",
-				"includeContent",
-				"filters"
-			],
-			body: false,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		getSchema: operation(request, {
-			method: "get",
-			path: "/content/entries/schema",
-			pathParams: [],
-			queryParams: [
-				"entryID",
-				"path",
-				"channel",
-				"snapshotID"
-			],
-			body: false,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		getAsset: operation(request, {
-			method: "get",
-			path: "/content/assets/{workspaceID}/{snapshotID}/{entryID}/{assetID}/{variant}",
-			pathParams: [
-				"workspaceID",
-				"snapshotID",
-				"entryID",
-				"assetID",
-				"variant"
-			],
-			queryParams: [],
-			body: false,
-			multipart: false,
-			binary: true,
-			anonymous: true
-		}),
-		get: operation(request, {
-			method: "get",
-			path: "/content/entries/get",
-			pathParams: [],
-			queryParams: [
-				"entryID",
-				"path",
-				"expectedSchemaHash",
-				"channel",
-				"snapshotID"
-			],
-			body: false,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		getTree: operation(request, {
-			method: "get",
-			path: "/content/tree",
-			pathParams: [],
-			queryParams: [
-				"collectionID",
-				"collectionPath",
-				"channel",
-				"snapshotID"
-			],
-			body: false,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		})
-	},
-	roles: {
-		list: operation(request, {
-			method: "get",
-			path: "/roles",
-			pathParams: [],
-			queryParams: [],
-			body: false,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		create: operation(request, {
-			method: "post",
-			path: "/roles",
-			pathParams: [],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		update: operation(request, {
-			method: "put",
-			path: "/roles/{id}",
-			pathParams: ["id"],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		delete: operation(request, {
-			method: "delete",
-			path: "/roles/{id}",
-			pathParams: ["id"],
-			queryParams: [],
-			body: false,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		})
-	},
-	search: {
-		current: operation(request, {
-			method: "post",
-			path: "/search/current",
-			pathParams: [],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		published: operation(request, {
-			method: "post",
-			path: "/search/published",
-			pathParams: [],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		askCurrent: operation(request, {
-			method: "post",
-			path: "/search/current/ask",
-			pathParams: [],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		askPublished: operation(request, {
-			method: "post",
-			path: "/search/published/ask",
-			pathParams: [],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		askCurrentStream: operation(request, {
-			streaming: true,
-			method: "post",
-			path: "/search/current/ask/stream",
-			pathParams: [],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		askPublishedStream: operation(request, {
-			streaming: true,
-			method: "post",
-			path: "/search/published/ask/stream",
-			pathParams: [],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		})
-	},
-	schemas: {
-		create: operation(request, {
-			method: "post",
-			path: "/collections/{collectionID}/schema",
-			pathParams: ["collectionID"],
-			queryParams: [],
-			body: false,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		delete: operation(request, {
-			method: "delete",
-			path: "/schemas/{schemaID}",
-			pathParams: ["schemaID"],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		getRevision: operation(request, {
-			method: "get",
-			path: "/schema-revisions/{revisionID}",
-			pathParams: ["revisionID"],
-			queryParams: [],
-			body: false,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		get: operation(request, {
-			method: "get",
-			path: "/schemas/collection",
-			pathParams: [],
-			queryParams: ["collectionID", "collectionPath"],
-			body: false,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		apply: operation(request, {
-			method: "post",
-			path: "/schemas/{schemaID}/apply",
-			pathParams: ["schemaID"],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		})
-	},
-	schemaMigrations: {
-		listContentLossEntries: operation(request, {
-			method: "get",
-			path: "/schema-migrations/{id}/content-loss-entries",
-			pathParams: ["id"],
-			queryParams: ["cursor", "limit"],
-			body: false,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		getActive: operation(request, {
-			method: "get",
-			path: "/collections/{collectionID}/schema-migration",
-			pathParams: ["collectionID"],
-			queryParams: [],
-			body: false,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		get: operation(request, {
-			method: "get",
-			path: "/schema-migrations/{id}",
-			pathParams: ["id"],
-			queryParams: [],
-			body: false,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		})
-	},
-	schemaVersions: {
-		list: operation(request, {
-			method: "get",
-			path: "/schemas/{schemaID}/versions",
-			pathParams: ["schemaID"],
-			queryParams: ["cursor", "limit"],
-			body: false,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		get: operation(request, {
-			method: "get",
-			path: "/schema-versions/{id}",
-			pathParams: ["id"],
-			queryParams: [],
-			body: false,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		update: operation(request, {
-			method: "patch",
-			path: "/schema-versions/{id}",
-			pathParams: ["id"],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		revert: operation(request, {
-			method: "post",
-			path: "/schema-versions/{id}/revert",
-			pathParams: ["id"],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		})
-	},
-	memberships: {
-		list: operation(request, {
-			method: "get",
-			path: "/memberships",
-			pathParams: [],
-			queryParams: ["cursor", "limit"],
-			body: false,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		invite: operation(request, {
-			method: "post",
-			path: "/memberships",
-			pathParams: [],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		update: operation(request, {
-			method: "patch",
-			path: "/memberships/{id}",
-			pathParams: ["id"],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		remove: operation(request, {
-			method: "delete",
-			path: "/memberships/{id}",
-			pathParams: ["id"],
-			queryParams: [],
-			body: false,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		listInvites: operation(request, {
-			method: "get",
-			path: "/memberships/invites",
-			pathParams: [],
-			queryParams: ["cursor", "limit"],
-			body: false,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		resendInvite: operation(request, {
-			method: "post",
-			path: "/memberships/invites/{id}/resend",
-			pathParams: ["id"],
-			queryParams: [],
-			body: false,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		revokeInvite: operation(request, {
-			method: "delete",
-			path: "/memberships/invites/{id}",
-			pathParams: ["id"],
-			queryParams: [],
-			body: false,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		})
-	},
-	publishing: {
-		setCollection: operation(request, {
-			method: "put",
-			path: "/publishing/collections/{collectionID}",
-			pathParams: ["collectionID"],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		publishCollection: operation(request, {
-			method: "post",
-			path: "/publishing/collections/{collectionID}",
-			pathParams: ["collectionID"],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		unpublishCollection: operation(request, {
-			method: "delete",
-			path: "/publishing/collections/{collectionID}",
-			pathParams: ["collectionID"],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		bulkSetCollections: operation(request, {
-			method: "post",
-			path: "/publishing/collections/bulk/set",
-			pathParams: [],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		bulkPublishCollections: operation(request, {
-			method: "post",
-			path: "/publishing/collections/bulk/publish",
-			pathParams: [],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		bulkUnpublishCollections: operation(request, {
-			method: "post",
-			path: "/publishing/collections/bulk/unpublish",
-			pathParams: [],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		publishEntry: operation(request, {
-			method: "post",
-			path: "/publishing/entries/{entryID}",
-			pathParams: ["entryID"],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		unpublishEntry: operation(request, {
-			method: "delete",
-			path: "/publishing/entries/{entryID}",
-			pathParams: ["entryID"],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		bulkPublishEntries: operation(request, {
-			method: "post",
-			path: "/publishing/entries/bulk/publish",
-			pathParams: [],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		bulkUnpublishEntries: operation(request, {
-			method: "post",
-			path: "/publishing/entries/bulk/unpublish",
-			pathParams: [],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		revertChanges: operation(request, {
-			method: "post",
-			path: "/publishing/changes/revert",
-			pathParams: [],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		getEntryVersion: operation(request, {
-			method: "get",
-			path: "/publishing/entries/{entryID}/version",
-			pathParams: ["entryID"],
-			queryParams: [
-				"channel",
-				"expectedSchemaHash",
-				"snapshotID"
-			],
-			body: false,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		listEntryPublications: operation(request, {
-			method: "get",
-			path: "/publishing/entries/{entryID}/publications",
-			pathParams: ["entryID"],
-			queryParams: [],
-			body: false,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		listChannels: operation(request, {
-			method: "get",
-			path: "/publishing/channels",
-			pathParams: [],
-			queryParams: ["includeAssignmentCount"],
-			body: false,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		createChannel: operation(request, {
-			method: "post",
-			path: "/publishing/channels",
-			pathParams: [],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		getChannelContent: operation(request, {
-			method: "get",
-			path: "/publishing/channels/{channel}/content",
-			pathParams: ["channel"],
-			queryParams: ["collectionID"],
-			body: false,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		deleteChannel: operation(request, {
-			method: "delete",
-			path: "/publishing/channels/{code}",
-			pathParams: ["code"],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		})
-	},
-	versions: {
-		create: operation(request, {
-			method: "post",
-			path: "/entries/{entryID}/versions",
-			pathParams: ["entryID"],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		list: operation(request, {
-			method: "get",
-			path: "/entries/{entryID}/versions",
-			pathParams: ["entryID"],
-			queryParams: ["cursor", "limit"],
-			body: false,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		get: operation(request, {
-			method: "get",
-			path: "/versions/{id}",
-			pathParams: ["id"],
-			queryParams: ["expectedSchemaHash"],
-			body: false,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		update: operation(request, {
-			method: "patch",
-			path: "/versions/{id}",
-			pathParams: ["id"],
-			queryParams: [],
-			body: true,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		}),
-		revert: operation(request, {
-			method: "post",
-			path: "/versions/{id}/revert",
-			pathParams: ["id"],
-			queryParams: [],
-			body: false,
-			multipart: false,
-			binary: false,
-			anonymous: false
-		})
-	}
-});
-//#endregion
-//#region src/retry.ts
-const wait = (delay, signal) => {
-	signal.throwIfAborted();
-	return new Promise((resolve, reject) => {
-		const abort = () => {
-			clearTimeout(timer);
-			reject(signal.reason);
-		};
-		const timer = setTimeout(() => {
-			signal.removeEventListener("abort", abort);
-			resolve();
-		}, delay);
-		signal.addEventListener("abort", abort, { once: true });
-	});
-};
-const retryDelay = (attempt, response) => {
-	const value = response?.headers.get("Retry-After");
-	const seconds = value === null || value === void 0 ? NaN : Number(value);
-	const date = value ? Date.parse(value) : NaN;
-	if (Number.isFinite(seconds)) return Math.max(0, seconds * 1e3);
-	if (Number.isFinite(date)) return Math.max(0, date - Date.now());
-	return Math.min(1e3 * 2 ** attempt, 3e4) + Math.random() * 250;
-};
-const fetchWithRetries = async (fetcher, request, retries) => {
-	const signal = request.signal;
-	for (let attempt = 0;; attempt += 1) {
-		let response;
-		signal.throwIfAborted();
-		try {
-			response = await fetcher(request.clone());
-		} catch (error) {
-			if (signal.aborted || attempt >= retries || !(error instanceof TypeError)) throw error;
-			await wait(retryDelay(attempt), signal);
-			continue;
-		}
-		if (attempt >= retries || ![
-			429,
-			500,
-			502,
-			503,
-			504
-		].includes(response.status)) return response;
-		const delay = retryDelay(attempt, response);
-		await response.body?.cancel();
-		await wait(delay, signal);
-	}
-};
-//#endregion
-//#region src/client.ts
-/**
-* Create a typed API client for a hosted or self-hosted Andesine instance.
-*
-* Methods return response data by default. Use response: "full" for status and headers,
-* including conditional reads that can return 304. Creation does not make a request.
-* @param config - Optional API root, credentials, transport, and request defaults.
-* Defaults to https://api.andesine.app and process.env.ANDESINE_API_KEY when available.
-* Runtimes without process.env use no default key. No environment files are loaded.
-* @returns API resources and helpers for published-content snapshots and pagination.
-* @throws TypeError if baseURL is not HTTP(S) or includes credentials, a query, or a fragment.
-* Request failures throw AndesineAPIError; abort and timeout reasons are preserved.
-* @example
-* const client = createClient();
-* const page = await client.content.get({ path: "/Docs/Welcome" });
-*/
-const createClient = (config = {}) => {
-	const baseURL = (config.baseURL ?? "https://api.andesine.app").replace(/\/+$/, "");
-	const apiKey = config.apiKey ?? globalThis.process?.env?.ANDESINE_API_KEY;
-	const url = new URL(baseURL);
-	const fetcher = config.fetch ?? globalThis.fetch;
-	if (!["http:", "https:"].includes(url.protocol) || url.search || url.hash || url.username || url.password) throw new TypeError("baseURL must be an HTTP(S) URL without credentials, query, or fragment");
-	const request = async (definition, input, options = {}) => {
-		const controller = new AbortController();
-		const signal = options.signal ? AbortSignal.any([controller.signal, options.signal]) : controller.signal;
-		const timeout = options.timeout ?? config.timeout ?? 3e4;
-		const retries = options.retries ?? config.retries ?? 0;
-		const headers = new Headers(config.headers);
-		const path = Object.fromEntries(definition.pathParams.map((key) => [key, input[key]]));
-		const query = Object.fromEntries(definition.queryParams.map((key) => [key, input[key]]));
-		const body = Object.fromEntries(Object.entries(input).filter(([key]) => !definition.pathParams.includes(key) && !definition.queryParams.includes(key)));
-		const client = createFetchClient({
-			baseUrl: baseURL,
-			querySerializer: serializeQuery
-		});
-		if (!Number.isFinite(timeout) || timeout < 0 || !Number.isInteger(retries) || retries < 0) throw new TypeError("timeout and retries must be nonnegative; retries must be an integer");
-		if (query.channel !== void 0 && query.snapshotID !== void 0) throw new TypeError("Use either channel or snapshotID, not both");
-		for (const key of definition.pathParams) if (input[key] === void 0 || input[key] === null) throw new TypeError(`Missing path parameter: ${key}`);
-		new Headers(options.headers).forEach((value, key) => headers.set(key, value));
-		if (definition.streaming && !headers.has("Accept")) headers.set("Accept", "text/event-stream");
-		if (apiKey && !definition.anonymous) headers.set("Authorization", `Bearer ${apiKey}`);
-		const timer = timeout > 0 ? setTimeout(() => controller.abort(new DOMException("Request timed out", "TimeoutError")), timeout) : void 0;
-		let streamOwnsRequest = false;
-		try {
-			const result = await client.request(definition.method, definition.path, {
-				params: {
-					path,
-					query
-				},
-				headers,
-				signal,
-				body: definition.body ? body : void 0,
-				parseAs: "stream",
-				bodySerializer: definition.multipart ? (value) => {
-					const form = new FormData();
-					for (const [key, item] of Object.entries(value)) if (item instanceof Blob) form.append(key, item);
-					else if (item !== void 0) form.append(key, typeof item === "string" ? item : JSON.stringify(item));
-					return form;
-				} : void 0,
-				fetch: (request) => fetchWithRetries(fetcher, request, definition.method === "get" ? retries : 0)
-			});
-			const response = result.response;
-			if (response.status === 304) {
-				if (options.response !== "full") throw new TypeError("Use response: 'full' for conditional requests that can return 304");
-				return {
-					status: 304,
-					headers: response.headers,
-					data: void 0,
-					notModified: true
-				};
-			}
-			if (!response.ok) throw new AndesineAPIError(response, result.error);
-			if (definition.streaming) {
-				const data = createAnswerStream(response, {
-					signal,
-					cancel: () => controller.abort(),
-					cleanup: () => {
-						if (timer !== void 0) clearTimeout(timer);
-					}
-				});
-				streamOwnsRequest = true;
-				return options.response === "full" ? {
-					status: response.status,
-					headers: response.headers,
-					data,
-					notModified: false
-				} : data;
-			}
-			const text = definition.binary || response.status === 204 ? void 0 : await response.text();
-			const data = definition.binary ? await response.blob() : text ? JSON.parse(text) : void 0;
-			return options.response === "full" ? {
-				status: response.status,
-				headers: response.headers,
-				data,
-				notModified: false
-			} : data;
-		} finally {
-			if (!streamOwnsRequest && timer !== void 0) clearTimeout(timer);
-		}
-	};
-	const resources = createResources(request);
-	return {
-		...resources,
-		content: createContentClient(resources.content),
-		atSnapshot(snapshotID) {
-			return createContentClient(createResources((definition, input, options) => {
-				const pinned = definition.path.startsWith("/content/") && definition.queryParams.includes("snapshotID");
-				if (pinned && (input.channel !== void 0 || input.snapshotID !== void 0 && input.snapshotID !== snapshotID)) throw new TypeError("Cannot override a pinned snapshot");
-				return request(definition, pinned ? {
-					...input,
-					snapshotID
-				} : input, options);
-			}).content);
-		}
-	};
-};
-//#endregion
+import { i as AndesineStreamProtocolError, n as AndesineAPIError, r as AndesineStreamError } from "./answer-stream-7N_gLhVS.js";
+import { n as paginate, r as paginatePages, t as createClient } from "./client-DioqVOxl.js";
+import { toContentSlug } from "./content-slug.js";
 //#region src/content-url.ts
 /**
 * Convert a canonical Andesine path or search/citation location to a website URL.
 *
-* Encodes each decoded path segment and anchor without changing case or deriving slugs.
+* Uses the API slugPath when supplied, or derives slugs from decoded names.
+* Set format to "name" to preserve names. Heading anchors are encoded without slug conversion.
 * This is a pure function: it does not resolve IDs, fetch content, or pin a snapshot.
-* @param source - An absolute decoded path (starting with /), or an object with path and anchor.
+* @param source - An absolute decoded path, or an API location with path, slugPath, and optional anchor.
 * Collection-ID-relative selectors must first be resolved through the API to a canonical path.
 * @param options - Source collection root and destination URL prefix.
 * @returns A root-relative URL by default, or an absolute URL when baseURL is absolute.
 * The source root itself maps to the destination root without adding a trailing slash.
-* @throws TypeError for invalid paths, a source outside rootPath, or an invalid baseURL.
+* @throws TypeError for invalid paths, a source outside rootPath, an invalid baseURL,
+* or a symbol-only name without an API slugPath. Pass the API object for ID fallbacks.
 * @example
 * toContentURL({ path: "/Docs/Getting started", anchor: "install" }, {
 *   rootPath: "/Docs", baseURL: "/docs"
-* }); // "/docs/Getting%20started#install"
+* }); // "/docs/getting-started#install"
 */
 const toContentURL = (source, options = {}) => {
 	const location = typeof source === "string" ? { path: source } : source;
 	const segments = contentPathSegments(location.path);
+	const useSlugs = options.format !== "name";
+	const outputSegments = useSlugs ? location.slugPath ? contentPathSegments(location.slugPath) : segments.map((segment) => toContentSlug(segment)) : segments;
 	const root = contentPathSegments(options.rootPath ?? "/");
-	const outsideRoot = root.some((segment, index) => segments[index] !== segment);
+	const outsideRoot = root.some((segment, index) => segments[index] !== segment && (!useSlugs || outputSegments[index] !== toContentSlug(segment)));
 	const baseURL = options.baseURL ?? "/";
 	const relative = baseURL.startsWith("/") && !baseURL.startsWith("//");
 	const url = new URL(baseURL, relative ? "https://andesine.invalid" : void 0);
 	const invalidBase = !["http:", "https:"].includes(url.protocol) || Boolean(url.search || url.hash || url.username || url.password) || baseURL.includes("\\");
+	if (outputSegments.length !== segments.length) throw new TypeError("path and slugPath must have the same number of segments");
 	if (outsideRoot) throw new TypeError("Content path is outside rootPath");
 	if (invalidBase) throw new TypeError("baseURL must be a root-relative or HTTP(S) URL without credentials, query, or fragment");
-	const suffix = segments.slice(root.length).map(encodeURIComponent).join("/");
+	const suffix = outputSegments.slice(root.length).map(encodeURIComponent).join("/");
 	const prefix = url.pathname.replace(/\/+$/, "");
 	url.pathname = (suffix ? `${prefix}/${suffix}` : prefix) || "/";
 	url.hash = location.anchor ? encodeURIComponent(location.anchor) : "";
@@ -1150,7 +53,7 @@ const contentPathSegments = (path) => {
 * @param page - Full entry content with properties and fragments, including published list items.
 * @returns A new object with property.value and fragment.content exposed by key. Other fields,
 * including schema metadata and assets, are preserved. Nested content is shared, not cloned.
-* This helper does not validate content, convert formats, or infer collection-specific types.
+* Workspace field types and revision unions are preserved. This helper does not validate content or convert formats.
 * @example
 * const tutorial = toStructuredContent(page);
 * const body = tutorial.fragments.body;
@@ -1158,10 +61,10 @@ const contentPathSegments = (path) => {
 */
 const toStructuredContent = (page) => ({
 	...page,
-	properties: Object.fromEntries(Object.entries(page.properties).map(([key, property]) => [key, property.value])),
-	fragments: Object.fromEntries(Object.entries(page.fragments).map(([key, fragment]) => [key, fragment.content]))
+	properties: Object.fromEntries(Object.entries(page.properties).map(([key, property]) => [key, property?.value])),
+	fragments: Object.fromEntries(Object.entries(page.fragments).map(([key, fragment]) => [key, fragment?.content]))
 });
 //#endregion
-export { AndesineAPIError, AndesineStreamError, AndesineStreamProtocolError, createClient, paginate, paginatePages, toContentURL, toStructuredContent };
+export { AndesineAPIError, AndesineStreamError, AndesineStreamProtocolError, createClient, paginate, paginatePages, toContentSlug, toContentURL, toStructuredContent };
 
 //# sourceMappingURL=index.js.map