@epam/ai-dial-chat-hooks 1.2.0-dev.15 → 1.2.0-dev.152

package/skill/skill.js

@@ -13,7 +13,10 @@ var i = "SKILL.md", a = 1048576, o = 16777216, s = 100, c = new Set([".dial-reso
 	...e,
 	name: t,
 	description: n
-}).trimEnd()}\n---\n\n${i}`, g = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/, _ = (e) => {
+}).trimEnd()}\n---\n\n${i}`, g = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/, _ = /^---[ \t]*$/, v = (e) => {
+	let t = e.replace(/^\uFEFF/, "").replace(/\r\n/g, "\n").split("\n"), n = t.findIndex((e) => e.trim() !== "");
+	return n === -1 || !_.test(t[n]) ? !1 : t.some((e, t) => t > n && _.test(e));
+}, y = (e) => {
 	let t = g.exec(e);
 	if (!t) throw Error("SKILL.md is missing its YAML frontmatter block");
 	let [, r, i] = t;
@@ -21,7 +24,7 @@ var i = "SKILL.md", a = 1048576, o = 16777216, s = 100, c = new Set([".dial-reso
 		frontmatter: n(r) ?? {},
 		instructions: i.replace(/^\r?\n/, "")
 	};
-}, v = (e) => {
+}, b = (e) => {
 	let n = t(e), r = n[i];
 	if (r == null) throw Error(`Skill archive is missing a root ${i} file`);
 	let a = /* @__PURE__ */ new Map();
@@ -30,19 +33,19 @@ var i = "SKILL.md", a = 1048576, o = 16777216, s = 100, c = new Set([".dial-reso
 		manifestText: new TextDecoder().decode(r),
 		files: a
 	};
-}, y = (e) => {
+}, x = (e) => {
 	let t = e.lastIndexOf("/");
 	return t === -1 ? e : e.slice(t + 1);
-}, b = (e) => new Blob([new Uint8Array(e)]), x = (e, t, n, r) => Object.keys(e).length > 0 ? h(e, t, n, r) : m({
+}, S = (e) => new Blob([new Uint8Array(e)]), C = (e, t, n, r) => Object.keys(e).length > 0 ? h(e, t, n, r) : m({
 	name: t,
 	description: n,
 	instructions: r
-}), S = (t, n) => {
+}), w = (t, n) => {
 	let r = t.filter((t) => t.kind === e.File);
 	return {
 		filePaths: r.map((e) => e.path),
-		files: r.map((e) => b(n.get(e.path)?.bytes ?? new Uint8Array()))
+		files: r.map((e) => S(n.get(e.path)?.bytes ?? new Uint8Array()))
 	};
 };
 //#endregion
-export { a as SKILL_FILE_UPLOAD_MAX_BYTES, i as SKILL_MANIFEST_FILE, s as SKILL_UPLOAD_MAX_FILES, o as SKILL_UPLOAD_MAX_TOTAL_BYTES, S as buildSkillFilesPayload, m as buildSkillManifest, x as buildSkillManifestForSubmit, h as buildSkillManifestFromFrontmatter, f as isValidSkillRelativePath, y as nameFromPath, p as normalizeSkillName, _ as parseSkillManifest, b as skillFileBytesToBlob, v as unpackSkillArchive };
+export { a as SKILL_FILE_UPLOAD_MAX_BYTES, i as SKILL_MANIFEST_FILE, s as SKILL_UPLOAD_MAX_FILES, o as SKILL_UPLOAD_MAX_TOTAL_BYTES, w as buildSkillFilesPayload, m as buildSkillManifest, C as buildSkillManifestForSubmit, h as buildSkillManifestFromFrontmatter, f as isValidSkillRelativePath, x as nameFromPath, p as normalizeSkillName, y as parseSkillManifest, S as skillFileBytesToBlob, v as startsWithFrontmatterBlock, b as unpackSkillArchive };

package/skill/useSkillArchiveImport/useSkillArchiveImport.js

@@ -0,0 +1,75 @@
+import { getApiErrorStatus as e } from "../../api-error/api-error.js";
+import { useCallback as t, useEffect as n, useRef as r, useState as i } from "react";
+//#region src/skill/useSkillArchiveImport/useSkillArchiveImport.ts
+var a = "SKILL.md", o = /* @__PURE__ */ function(e) {
+	return e.Idle = "idle", e.Uploading = "uploading", e.Success = "success", e.Error = "error", e;
+}({}), s = /* @__PURE__ */ function(e) {
+	return e.Validation = "validation", e.Collision = "collision", e.RateLimited = "rateLimited", e.ServiceUnavailable = "serviceUnavailable", e.Generic = "generic", e;
+}({}), c = /* @__PURE__ */ function(e) {
+	return e.UnsupportedFilename = "unsupportedFilename", e;
+}({}), l = (e) => {
+	switch (e) {
+		case 400:
+		case 413:
+		case 422: return "validation";
+		case 409: return "collision";
+		case 429: return "rateLimited";
+		case 502:
+		case 503: return "serviceUnavailable";
+		default: return "generic";
+	}
+}, u = (e, t) => e.toLowerCase().endsWith(".md") && e !== t, d = ({ importArchive: o, onImported: s, onError: c, manifestFileName: d = a }) => {
+	let [f, p] = i(!1), [m, h] = i("idle"), [g, _] = i(void 0), [v, y] = i(void 0), b = r(!1), x = r(!0);
+	n(() => (x.current = !0, () => {
+		x.current = !1;
+	}), []);
+	let S = t(async (t) => {
+		b.current = !0, h("uploading"), y(void 0);
+		try {
+			let e = await o(t);
+			if (!x.current || (await s(e), !x.current)) return;
+			h("success");
+		} catch (t) {
+			if (!x.current) return;
+			let n = l(e(t));
+			h("error"), y(n), c(t, n);
+		} finally {
+			b.current = !1;
+		}
+	}, [
+		o,
+		s,
+		c
+	]), C = t(() => {
+		b.current || (_(void 0), p(!0));
+	}, []), w = t(() => {
+		p(!1), _(void 0);
+	}, []), T = t(() => {
+		h("error"), _("unsupportedFilename");
+	}, []);
+	return {
+		isDialogOpen: f,
+		status: m,
+		selectionRejectionReason: g,
+		errorKind: v,
+		openDialog: C,
+		closeDialog: w,
+		handleFilesSelected: t((e) => {
+			let t = e[0];
+			if (!(!t || b.current)) {
+				if (u(t.name, d)) {
+					T();
+					return;
+				}
+				_(void 0), p(!1), S(t);
+			}
+		}, [
+			d,
+			T,
+			S
+		]),
+		handleFilesRejected: T
+	};
+};
+//#endregion
+export { s as SkillArchiveImportErrorKind, o as SkillArchiveImportStatus, c as SkillArchiveSelectionRejectionReason, l as classifySkillArchiveImportError, d as useSkillArchiveImport };

package/skill/useSkillEditorLoad.js

@@ -6,12 +6,12 @@ import { SkillFileNodeKind as u } from "@epam/ai-dial-skill-editor";
 //#region src/skill/useSkillEditorLoad.ts
 var d = /* @__PURE__ */ function(e) {
 	return e.Loading = "loading", e.Loaded = "loaded", e.Error = "error", e.Forbidden = "forbidden", e.NotFound = "not-found", e;
-}({}), f = class extends Error {}, p = (e, r) => {
+}({}), f = class extends Error {}, p = class extends Error {}, m = (e, r) => {
 	let i = e.parentPath ? t(e.parentPath) : "", a = `${n(r)}/files`;
 	return i === a ? e.name : i.startsWith(`${a}/`) ? `${i.slice(a.length + 1)}/${e.name}` : i === "files" ? e.name : i.startsWith("files/") ? `${i.slice(6)}/${e.name}` : null;
-}, m = async (e, t, n) => {
+}, h = async (e, t, n) => {
 	let r = await e.downloadSkill(t, n), i = r.headers.get("etag");
-	if (!i) throw new f("Skill ETag is missing");
+	if (!i) throw new p("Skill ETag is missing");
 	try {
 		let e = await r.arrayBuffer(), { manifestText: t, files: n } = o(new Uint8Array(e));
 		return {
@@ -22,17 +22,17 @@ var d = /* @__PURE__ */ function(e) {
 	} catch {
 		throw new f("Skill ZIP is invalid");
 	}
-}, h = async (e, t, n) => {
+}, g = async (e, t, n) => {
 	let [i, a] = await Promise.all([e.downloadSkillFile(t, n, r), e.listSkillFiles({
 		bucket: t,
 		path: n,
 		filePath: "",
 		recursive: !0
-	})]), o = a.items.find((e) => e.nodeType === "item" && p(e, n) === "SKILL.md"), s = i.headers.get("etag") ?? o?.etag;
-	if (!s) throw Error("Skill ETag is missing");
+	})]), o = a.items.find((e) => e.nodeType === "item" && m(e, n) === "SKILL.md"), s = i.headers.get("etag") ?? o?.etag;
+	if (!s) throw new p("Skill ETag is missing");
 	let c = a.items.filter((e) => e.nodeType === "item").map((e) => ({
 		item: e,
-		path: p(e, n)
+		path: m(e, n)
 	})).filter((e) => e.path != null && e.path !== "SKILL.md"), l = await Promise.all(c.map(async ({ path: r }) => {
 		let i = await e.downloadSkillFile(t, n, r);
 		return [r, new Uint8Array(await i.arrayBuffer())];
@@ -42,40 +42,41 @@ var d = /* @__PURE__ */ function(e) {
 		manifestText: await i.text(),
 		files: new Map(l)
 	};
-}, g = ({ isEditMode: t, bucket: n, skillPath: r, client: o }) => {
-	let [d, p] = l(t ? "loading" : "loaded"), [g, _] = l(0), [v, y] = l(), b = c(void 0), x = c({}), S = c(void 0), [C, w] = l([]), T = c(/* @__PURE__ */ new Map());
+}, _ = ({ isEditMode: t, bucket: n, skillPath: r, client: o }) => {
+	let [d, m] = l(t ? "loading" : "loaded"), [_, v] = l(0), [y, b] = l(), x = c(void 0), S = c({}), C = c(void 0), [w, T] = l([]), E = c(/* @__PURE__ */ new Map());
 	return s(() => {
 		if (!t || !n) return;
 		if (r == null) {
-			p("error");
+			m("error");
 			return;
 		}
 		let s = !1;
-		return p("loading"), (async () => {
+		return m("loading"), (async () => {
 			if (await Promise.resolve(), !s) try {
 				let t;
 				try {
-					t = await m(o, n, r);
+					t = await h(o, n, r);
 				} catch (i) {
+					if (i instanceof p) throw i;
 					let a = e(i);
 					if (!(i instanceof f) && a !== 400) throw i;
-					t = await h(o, n, r);
+					t = await g(o, n, r);
 				}
 				let { frontmatter: c, instructions: l } = a(t.manifestText);
 				if (s) return;
-				b.current = t.etag, x.current = c, S.current = r, T.current = new Map([...t.files].map(([e, t]) => [e, { bytes: t }])), w([...t.files.keys()].map((e) => ({
+				x.current = t.etag, S.current = c, C.current = r, E.current = new Map([...t.files].map(([e, t]) => [e, { bytes: t }])), T([...t.files.keys()].map((e) => ({
 					path: e,
 					name: i(e),
 					kind: u.File
-				}))), y({
+				}))), b({
 					name: typeof c.name == "string" ? c.name : "",
 					description: typeof c.description == "string" ? c.description : "",
 					instructions: l
-				}), p("loaded");
+				}), m("loaded");
 			} catch (t) {
 				if (s) return;
 				let n = e(t);
-				p(n === 403 ? "forbidden" : n === 404 ? "not-found" : "error");
+				m(n === 403 ? "forbidden" : n === 404 ? "not-found" : "error");
 			}
 		})(), () => {
 			s = !0;
@@ -84,20 +85,20 @@ var d = /* @__PURE__ */ function(e) {
 		t,
 		n,
 		r,
-		g,
+		_,
 		o
 	]), {
 		loadState: d,
-		loadedValues: v,
-		setLoadedValues: y,
-		files: C,
-		setFiles: w,
-		filesContentRef: T,
-		frontmatterRef: x,
-		etagRef: b,
-		loadedPathRef: S,
-		retryLoad: () => _((e) => e + 1)
+		loadedValues: y,
+		setLoadedValues: b,
+		files: w,
+		setFiles: T,
+		filesContentRef: E,
+		frontmatterRef: S,
+		etagRef: x,
+		loadedPathRef: C,
+		retryLoad: () => v((e) => e + 1)
 	};
 };
 //#endregion
-export { d as SkillEditorLoadState, g as useSkillEditorLoad };
+export { d as SkillEditorLoadState, _ as useSkillEditorLoad };

package/skill/useSkillEditorSubmit.js

@@ -1,135 +1,153 @@
 import { getApiErrorDetails as e, getApiErrorStatus as t } from "../api-error/api-error.js";
-import { buildSkillFilesPayload as n, buildSkillManifestForSubmit as r, isValidSkillRelativePath as i, normalizeSkillName as a } from "./skill.js";
-import { useCallback as o, useRef as s, useState as c } from "react";
-import { NotificationVariant as l } from "@epam/ai-dial-ui-kit";
+import { buildSkillFilesPayload as n, buildSkillManifestForSubmit as r, isValidSkillRelativePath as i, normalizeSkillName as a, startsWithFrontmatterBlock as o } from "./skill.js";
+import { useCallback as s, useRef as c, useState as l } from "react";
+import { NotificationVariant as u } from "@epam/ai-dial-ui-kit";
 //#region src/skill/useSkillEditorSubmit.ts
-var u = (e, t) => JSON.stringify({
+var d = (e, t) => JSON.stringify({
 	values: e,
 	files: [...t].sort((e, t) => e.path.localeCompare(t.path))
-}), d = ({ bucket: d, isEditMode: f, files: p, filesContentRef: m, frontmatterRef: h, loadedPathRef: g, etagRef: _, returnUrl: v, refetchSkills: y, client: b, messages: x, onNavigate: S, onNotify: C }) => {
-	let [w, T] = c({}), [E, D] = c(), [O, k] = c(), [A, j] = c("idle"), M = s(null), N = o(async (n) => {
+}), f = ({ bucket: f, isEditMode: p, files: m, filesContentRef: h, frontmatterRef: g, loadedPathRef: _, etagRef: v, returnUrl: y, getCreateReturnUrl: b, refetchSkills: x, client: S, messages: C, onNavigate: w, onNotify: T }) => {
+	let [E, D] = l({}), [O, k] = l(), [A, j] = l(!1), [M, N] = l(), [P, F] = l("idle"), I = c(null), L = c(null), R = s(async (n) => {
 		switch (t(n)) {
 			case 409:
-				T({ name: x.nameConflict });
+				D({ name: C.nameConflict });
 				return;
 			case 412:
-				T({ name: x.nameConflict });
+				D({ name: C.nameConflict });
 				return;
 			case 413:
-				D(x.archiveTooLarge);
+				k(C.archiveTooLarge);
 				return;
 			case 503:
-				D(x.serviceUnavailable);
+				k(C.serviceUnavailable), j(!0);
 				return;
 			case 400: {
 				let { message: t } = await e(n);
-				D(t ?? x.pathInvalid);
+				k(t ?? C.pathInvalid);
 				return;
 			}
 			default: {
 				let { traceId: t } = await e(n);
-				D(x.saveError), C({
-					variant: l.Error,
-					message: x.saveError,
+				k(C.saveError), T({
+					variant: u.Error,
+					message: C.saveError,
 					requestId: t
 				});
 			}
 		}
-	}, [x, C]), P = o(async (e) => {
+	}, [C, T]), z = s(async (e) => {
 		let t = a(e.name);
 		if (!t || !i(t)) {
-			T({ name: x.nameInvalid });
+			D({ name: C.nameInvalid });
 			return;
 		}
-		let o = u(e, p), s = M.current, c = s != null && s.fingerprint === o, f = t, g, _, w;
-		c ? {skillManifest: g, filePaths: _, files: w} = s : (g = r(h.current, t, e.description, e.instructions), {filePaths: _, files: w} = n(p, m.current)), j("submitting"), M.current = {
+		let o = d(e, m), s = I.current, c = s != null && s.fingerprint === o, l = t, p, _, v;
+		c ? {skillManifest: p, filePaths: _, files: v} = s : (p = r(g.current, t, e.description, e.instructions), {filePaths: _, files: v} = n(m, h.current)), F("submitting"), I.current = {
 			fingerprint: o,
-			bucket: d,
-			path: f,
-			skillManifest: g,
+			bucket: f,
+			path: l,
+			skillManifest: p,
 			filePaths: _,
-			files: w
+			files: v
 		};
 		try {
-			await b.createSkill(d, f, g, _, w), await y(), j("success"), C({
-				variant: l.Success,
-				title: x.saveSuccessTitle,
-				message: x.createSuccess(t)
-			}), S(v);
+			await S.createSkill(f, l, p, _, v), await x(), F("success"), T({
+				variant: u.Success,
+				title: C.saveSuccessTitle,
+				message: C.createSuccess(t)
+			}), w(b?.(l) ?? y);
 		} catch (e) {
-			j("failure"), await N(e);
+			F("failure"), await R(e);
 		}
 	}, [
-		d,
-		p,
+		f,
 		m,
 		h,
-		x,
-		b,
+		g,
 		C,
 		S,
-		v,
+		T,
+		w,
 		y,
-		N
-	]), F = o(async (e) => {
-		let i = g.current, a = _.current;
+		b,
+		x,
+		R
+	]), B = s(async (e) => {
+		let i = _.current, a = v.current;
 		if (!i || !a) {
-			D(x.saveError);
+			k(C.saveError);
 			return;
 		}
-		let o = r(h.current, e.name, e.description, e.instructions), { filePaths: s, files: c } = n(p, m.current);
-		j("submitting");
+		let o = r(g.current, e.name, e.description, e.instructions), { filePaths: s, files: c } = n(m, h.current);
+		F("submitting");
 		try {
-			_.current = (await b.updateSkill(d, i, o, s, c, a)).etag ?? a, await y(), j("success"), C({
-				variant: l.Success,
-				title: x.updateSuccessTitle,
-				message: x.updateSuccess(e.name)
-			}), S(v);
+			v.current = (await S.updateSkill(f, i, o, s, c, a)).etag ?? a, await x(), F("success"), T({
+				variant: u.Success,
+				title: C.updateSuccessTitle,
+				message: C.updateSuccess(e.name)
+			}), w(y);
 		} catch (e) {
-			if (j("failure"), t(e) === 412) {
-				k({ message: x.conflictMessage });
+			if (F("failure"), t(e) === 412) {
+				N({ message: C.conflictMessage });
 				return;
 			}
-			await N(e);
+			await R(e);
 		}
 	}, [
-		d,
-		p,
+		f,
 		m,
 		h,
 		g,
 		_,
-		x,
-		b,
+		v,
 		C,
 		S,
-		v,
+		T,
+		w,
 		y,
-		N
+		x,
+		R
+	]), V = s((e) => {
+		let t = o(e.instructions);
+		D((e) => {
+			if (t === (e.instructions === C.instructionsFrontmatter)) return e;
+			if (t) return {
+				...e,
+				instructions: C.instructionsFrontmatter
+			};
+			let n = { ...e };
+			return delete n.instructions, n;
+		});
+	}, [C]), H = s(async (e) => {
+		if (P === "submitting" || !f) return;
+		let t = {};
+		if (e.name.trim() || (t.name = C.required), e.description.trim() || (t.description = C.required), e.instructions.trim() ? o(e.instructions) && (t.instructions = C.instructionsFrontmatter) : t.instructions = C.required, Object.keys(t).length > 0) {
+			D(t);
+			return;
+		}
+		D({}), k(void 0), j(!1), N(void 0), L.current = e, p ? await B(e) : await z(e);
+	}, [
+		P,
+		f,
+		C,
+		p,
+		B,
+		z
 	]);
 	return {
-		phase: A,
-		errors: w,
-		submitError: E,
-		conflict: O,
-		clearConflict: () => k(void 0),
-		handleSubmit: o(async (e) => {
-			if (A === "submitting" || !d) return;
-			let t = {};
-			if (e.name.trim() || (t.name = x.required), e.description.trim() || (t.description = x.required), e.instructions.trim() || (t.instructions = x.required), Object.keys(t).length > 0) {
-				T(t);
-				return;
-			}
-			T({}), D(void 0), k(void 0), f ? await F(e) : await P(e);
-		}, [
-			A,
-			d,
-			x,
-			f,
-			F,
-			P
-		])
+		phase: P,
+		errors: E,
+		submitError: O,
+		isSubmitErrorRetryable: A,
+		retrySubmit: s(() => {
+			let e = L.current;
+			e != null && H(e);
+		}, [H]),
+		conflict: M,
+		clearConflict: () => N(void 0),
+		handleSubmit: H,
+		handleValuesChange: V
 	};
 };
 //#endregion
-export { d as useSkillEditorSubmit };
+export { f as useSkillEditorSubmit };

package/skill-editor.d.ts

@@ -43,6 +43,13 @@ export declare const buildSkillManifestForSubmit: (frontmatter: Record<string, u
  */
 export declare const buildSkillManifestFromFrontmatter: (baseFrontmatter: Record<string, unknown>, name: string, description: string, instructions: string) => string;
 
+/**
+ * Classifies an import request's HTTP status into a semantic outcome: 400/413/422 are
+ * archive-content problems, 409 is a name collision, 429 is rate limiting, 502/503 mean the
+ * backend is unavailable, and anything else (including no status at all) is generic.
+ */
+export declare const classifySkillArchiveImportError: (status: number | undefined) => SkillArchiveImportErrorKind;
+
 /**
  * Client-side mirror of the backend's `isValidSkillRelativePath`
  * (`apps/chat-api/src/skills/utils/skill-path.util.ts`), used only for
@@ -122,6 +129,28 @@ export declare interface SkillAboutDetails {
     skillPrompt?: string;
 }
 
+/** Semantic classification of an import request failure. */
+export declare enum SkillArchiveImportErrorKind {
+    Validation = "validation",
+    Collision = "collision",
+    RateLimited = "rateLimited",
+    ServiceUnavailable = "serviceUnavailable",
+    Generic = "generic"
+}
+
+/** Phase of a skill-archive import, driving the host's loading/success/error presentation. */
+export declare enum SkillArchiveImportStatus {
+    Idle = "idle",
+    Uploading = "uploading",
+    Success = "success",
+    Error = "error"
+}
+
+/** Reason a selected/dropped file was rejected before any request was made. */
+export declare enum SkillArchiveSelectionRejectionReason {
+    UnsupportedFilename = "unsupportedFilename"
+}
+
 /** Already-configured DIAL Core download operations `useSkillEditorLoad` needs. */
 export declare interface SkillEditorLoadClient {
     /** Downloads the whole-skill ZIP archive. */
@@ -163,6 +192,12 @@ export declare interface SkillEditorSubmitClient {
 export declare interface SkillEditorSubmitMessages {
     /** Shown when a required field is empty. */
     required: string;
+    /**
+     * Shown when the Instructions value opens with its own YAML frontmatter
+     * block — pasting a whole `SKILL.md` in there would otherwise produce a
+     * manifest with two frontmatter blocks.
+     */
+    instructionsFrontmatter: string;
     /** Shown when the normalized skill name fails DIAL's naming rules. */
     nameInvalid: string;
     /** Shown when the skill name already exists (409), or defensively on an unreachable create-mode 412. */
@@ -328,6 +363,28 @@ export declare interface SkillManifestValues {
     instructions: string;
 }
 
+/**
+ * Answers one question: would appending this text after the fence that
+ * `buildSkillManifest` writes produce a *second* frontmatter block?
+ *
+ * That happens when the text's first non-blank line is a bare `---` and some
+ * later line is a bare `---` too — the exact shape of a `SKILL.md` pasted
+ * wholesale into the editor's Instructions field.
+ *
+ * Detection is deliberately structural rather than YAML-based: a pasted block
+ * whose fenced content fails to parse corrupts the stored manifest
+ * identically (and renders as a setext `h2` in the Catalog's Details tab just
+ * the same), so requiring parseable YAML here would let the worst cases
+ * through. Keeping `parseYaml` out also makes this cheap enough to run on
+ * every keystroke.
+ *
+ * A single unclosed fence returns `false`: with no closing fence there is no
+ * second block, matching `FRONTMATTER_PATTERN`'s own requirement. A `---`
+ * appearing later in the body (a horizontal rule, a setext underline) is
+ * likewise not a frontmatter block.
+ */
+export declare const startsWithFrontmatterBlock: (text: string) => boolean;
+
 declare type SubmitPhase = 'idle' | 'submitting' | 'success' | 'failure';
 
 /** A skill archive unpacked into its manifest text and a relative-path → bytes map of every other entry. */
@@ -346,6 +403,46 @@ export declare interface UnpackedSkillArchive {
  */
 export declare const unpackSkillArchive: (bytes: Uint8Array) => UnpackedSkillArchive;
 
+/**
+ * Headless controller for the skill-archive upload flow: dialog visibility, the exact-filename
+ * precheck, in-flight exclusion, and import completion. The host supplies the configured request
+ * and observes completion/failure through the injected callbacks; the hook never imports app
+ * contexts, i18n, or a configured API client.
+ */
+export declare const useSkillArchiveImport: <TResult>({ importArchive, onImported, onError, manifestFileName, }: UseSkillArchiveImportOptions<TResult>) => UseSkillArchiveImportResult;
+
+/** Options accepted by {@link useSkillArchiveImport}. */
+export declare interface UseSkillArchiveImportOptions<TResult> {
+    /** Submits the selected archive; the host owns request configuration and the client. */
+    importArchive: (file: File) => Promise<TResult>;
+    /** Called once after a successful import (and any awaited host follow-up) settles. */
+    onImported: (result: TResult) => void | Promise<void>;
+    /** Called once when the import request, or the host's follow-up in {@link onImported}, fails. */
+    onError: (error: unknown, kind: SkillArchiveImportErrorKind) => void;
+    /** Exact filename treated as the skill manifest. Defaults to `'SKILL.md'`. */
+    manifestFileName?: string;
+}
+
+/** Result returned by {@link useSkillArchiveImport}. */
+export declare interface UseSkillArchiveImportResult {
+    /** Whether the upload dialog is open. */
+    isDialogOpen: boolean;
+    /** Current phase of the import. */
+    status: SkillArchiveImportStatus;
+    /** Reason the current/last selection was rejected locally; `undefined` once cleared. */
+    selectionRejectionReason: SkillArchiveSelectionRejectionReason | undefined;
+    /** Classified failure of the last import request; `undefined` outside a request failure. */
+    errorKind: SkillArchiveImportErrorKind | undefined;
+    /** Opens the dialog, unless an import is already in flight. */
+    openDialog: () => void;
+    /** Closes the dialog and clears any rejection reason. */
+    closeDialog: () => void;
+    /** Wire to the dialog drop zone's `onChange`. */
+    handleFilesSelected: (files: File[]) => void;
+    /** Wire to the dialog drop zone's `onReject`. */
+    handleFilesRejected: () => void;
+}
+
 /**
  * Owns the edit-mode skill download/unpack/parse flow: the in-memory
  * supporting-file map, the loaded manifest values and frontmatter, the
@@ -397,7 +494,7 @@ export declare interface UseSkillEditorLoadResult {
  * `client.createSkill`/`client.updateSkill`, and mapping the resulting
  * success/error/conflict outcomes to presentable state.
  */
-export declare const useSkillEditorSubmit: ({ bucket, isEditMode, files, filesContentRef, frontmatterRef, loadedPathRef, etagRef, returnUrl, refetchSkills, client, messages, onNavigate, onNotify, }: UseSkillEditorSubmitParams) => UseSkillEditorSubmitResult;
+export declare const useSkillEditorSubmit: ({ bucket, isEditMode, files, filesContentRef, frontmatterRef, loadedPathRef, etagRef, returnUrl, getCreateReturnUrl, refetchSkills, client, messages, onNavigate, onNotify, }: UseSkillEditorSubmitParams) => UseSkillEditorSubmitResult;
 
 /** Parameters accepted by {@link useSkillEditorSubmit}. */
 export declare interface UseSkillEditorSubmitParams {
@@ -417,6 +514,8 @@ export declare interface UseSkillEditorSubmitParams {
     etagRef: React.MutableRefObject<string | undefined>;
     /** Where to navigate on a successful save. */
     returnUrl: string;
+    /** Resolves the destination after creation from the normalized skill path. Defaults to `returnUrl`. */
+    getCreateReturnUrl?: (path: string) => string;
     /** Refetches the host's skill listing after a successful save. */
     refetchSkills: () => Promise<void>;
     /** Already-configured create/update operations. */
@@ -437,6 +536,10 @@ export declare interface UseSkillEditorSubmitResult {
     errors: SkillEditorErrors;
     /** General submit-time error, distinct from a stale-edit `conflict`. */
     submitError: string | undefined;
+    /** Whether `submitError` was caused by something a plain re-send can clear, rather than by the submission itself. */
+    isSubmitErrorRetryable: boolean;
+    /** Re-submits the values of the attempt that produced `submitError`. No-op before the first submit. */
+    retrySubmit: () => void;
     /** Present when the last save hit a stale-ETag conflict. */
     conflict: {
         message: string;
@@ -445,6 +548,12 @@ export declare interface UseSkillEditorSubmitResult {
     clearConflict: () => void;
     /** Validates and submits the given form values. */
     handleSubmit: (values: SkillEditorValues) => Promise<void>;
+    /**
+     * Re-runs the Instructions frontmatter check against the editor's current
+     * values, so a pasted `SKILL.md` is flagged as the text lands rather than
+     * only on submit. Pass as the editor's `onValuesChange`.
+     */
+    handleValuesChange: (values: SkillEditorValues) => void;
 }
 
 /**