@epam/ai-dial-chat-hooks 1.2.0-dev.21 → 1.2.0-dev.213

package/skill/useSkillEditorSubmit.js

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

package/skill/useSkillFileActions.js

@@ -1,99 +1,111 @@
-import { SKILL_MANIFEST_FILE as e, buildSkillManifest as t, buildSkillManifestFromFrontmatter as n, nameFromPath as r } from "./skill.js";
-import { validateSkillFileBatch as i } from "./skill-file-batch-validation.js";
-import { getUtf8ByteLength as a } from "@epam/ai-dial-chat-shared";
-import { useCallback as o, useMemo as s, useRef as c, useState as l } from "react";
-import { SkillFileNodeKind as u } from "@epam/ai-dial-skill-editor";
+import { SKILL_MANIFEST_FILE as e, buildSkillManifest as t, buildSkillManifestFromFrontmatter as n, isValidSkillRelativePath as r, nameFromPath as i } from "./skill.js";
+import { validateSkillFileBatch as a } from "./skill-file-batch-validation.js";
+import { extractSkillArchive as o } from "./skill-archive.js";
+import { getUtf8ByteLength as s } from "@epam/ai-dial-chat-shared";
+import { useCallback as c, useMemo as l, useRef as u, useState as d } from "react";
+import { SkillFileNodeKind as f } from "@epam/ai-dial-skill-editor";
 //#region src/skill/useSkillFileActions.ts
-var d = ({ files: d, setFiles: f, filesContentRef: p, frontmatterRef: m, loadedValues: h, setLoadedValues: g, isEditMode: _, isDirty: v, setSelectedPath: y, messages: b }) => {
-	let [x, S] = l(!1), C = c(null), w = o(() => {
-		let e = d.filter((e) => e.kind === u.File).map((e) => e.path), r = 0;
-		for (let t of e) r += p.current.get(t)?.bytes.length ?? 0;
+var p = "probe", m = ({ files: m, setFiles: h, filesContentRef: g, frontmatterRef: _, loadedValues: v, setLoadedValues: y, isEditMode: b, isDirty: x, setSelectedPath: S, messages: C, pickFromFileSystem: w }) => {
+	let [T, E] = d(!1), D = u(null), O = c(() => {
+		let e = m.filter((e) => e.kind === f.File).map((e) => e.path), r = 0;
+		for (let t of e) r += g.current.get(t)?.bytes.length ?? 0;
 		let i = {
-			name: h?.name ?? "",
-			description: h?.description ?? "",
-			instructions: h?.instructions ?? ""
-		}, o = _ ? n(m.current, i.name, i.description, i.instructions) : t(i);
+			name: v?.name ?? "",
+			description: v?.description ?? "",
+			instructions: v?.instructions ?? ""
+		}, a = b ? n(_.current, i.name, i.description, i.instructions) : t(i);
 		return {
 			existingPaths: e,
 			existingTotalBytes: r,
-			manifestByteLength: a(o),
-			messages: b
+			manifestByteLength: s(a),
+			messages: C
 		};
 	}, [
-		d,
-		p,
-		_,
 		m,
-		h,
-		b
-	]), T = o(() => new Promise((e) => {
-		C.current = e, S(!0);
-	}), []), E = o((e) => {
-		S(!1), C.current?.(e), C.current = null;
+		g,
+		b,
+		_,
+		v,
+		C
+	]), k = c(() => new Promise((e) => {
+		D.current = e, E(!0);
+	}), []), A = c((e) => {
+		E(!1), D.current?.(e), D.current = null;
 	}, []);
 	return {
-		fileActions: s(() => ({
+		fileActions: l(() => ({
 			validateBatch: async (e) => {
-				let { results: t, batchErrors: n } = await i(e, w());
+				let { results: t, batchErrors: n } = await a(e, O());
 				return {
 					results: t,
 					batchErrors: n
 				};
 			},
 			commitBatch: async (e) => {
-				let { results: t, batchErrors: n, manifestCandidate: a } = await i(e, w());
-				if (t.some((e) => e.error !== void 0) || n.length > 0) return { error: n[0]?.message ?? b.saveError };
-				if (a) {
-					if (_ && a.name !== (h?.name ?? "")) return { error: b.manifestNameMismatch };
-					if ((_ || v) && !await T()) return { error: b.manifestImportDeclined };
+				let { results: t, batchErrors: n, manifestCandidate: r } = await a(e, O());
+				if (t.some((e) => e.error !== void 0) || n.length > 0) return { error: n[0]?.message ?? C.saveError };
+				if (r) {
+					if (b && r.name !== (v?.name ?? "")) return { error: C.manifestNameMismatch };
+					if ((b || x) && !await k()) return { error: C.manifestImportDeclined };
 				}
 				try {
-					let t = e.filter((e) => e.id !== a?.candidateId), n = await Promise.all(t.map(async (e) => ({
+					let t = e.filter((e) => e.id !== r?.candidateId), n = await Promise.all(t.map(async (e) => ({
 						path: e.path,
 						bytes: new Uint8Array(await e.file.arrayBuffer()),
 						mimeType: e.file.type || void 0
 					})));
-					for (let e of n) p.current.set(e.path, {
+					for (let e of n) g.current.set(e.path, {
 						bytes: e.bytes,
 						mimeType: e.mimeType
 					});
-					return n.length > 0 && f((e) => [...e, ...n.map((e) => ({
+					return n.length > 0 && h((e) => [...e, ...n.map((e) => ({
 						path: e.path,
-						name: r(e.path),
-						kind: u.File
-					}))]), a && (m.current = _ ? {
-						...m.current,
-						...a.frontmatter
-					} : a.frontmatter, g({
-						name: _ ? h?.name ?? a.name : a.name,
-						description: a.description,
-						instructions: a.instructions
+						name: i(e.path),
+						kind: f.File
+					}))]), r && (_.current = b ? {
+						..._.current,
+						...r.frontmatter
+					} : r.frontmatter, y({
+						name: b ? v?.name ?? r.name : r.name,
+						description: r.description,
+						instructions: r.instructions
 					})), {};
 				} catch (e) {
 					return { error: e instanceof Error ? e.message : String(e) };
 				}
 			},
 			onRemoveNode: (t) => {
-				f((e) => e.filter((e) => e.path !== t && !e.path.startsWith(`${t}/`)));
-				for (let e of [...p.current.keys()]) (e === t || e.startsWith(`${t}/`)) && p.current.delete(e);
-				y((n) => n === t || n.startsWith(`${t}/`) ? e : n);
-			}
+				h((e) => e.filter((e) => e.path !== t && !e.path.startsWith(`${t}/`)));
+				for (let e of [...g.current.keys()]) (e === t || e.startsWith(`${t}/`)) && g.current.delete(e);
+				S((n) => n === t || n.startsWith(`${t}/`) ? e : n);
+			},
+			onCreateFolder: (e) => {
+				h((t) => t.some((t) => t.path === e) ? t : [...t, {
+					path: e,
+					name: i(e),
+					kind: f.Folder
+				}]);
+			},
+			validateFolderPath: (e) => r(`${e}/${p}`) ? void 0 : C.pathInvalid,
+			extractArchive: o,
+			pickFromFileSystem: w
 		}), [
-			w,
-			_,
+			O,
+			b,
+			x,
 			v,
-			h,
-			T,
-			p,
-			m,
-			f,
+			k,
 			g,
+			_,
+			h,
 			y,
-			b
+			S,
+			C,
+			w
 		]),
-		pendingManifestImport: x,
-		resolveManifestImport: E
+		pendingManifestImport: T,
+		resolveManifestImport: A
 	};
 };
 //#endregion
-export { d as useSkillFileActions };
+export { m as useSkillFileActions };

package/skill-editor.d.ts

@@ -7,6 +7,7 @@ import { SkillEditorFileActions } from '@epam/ai-dial-skill-editor';
 import { SkillEditorValues } from '@epam/ai-dial-skill-editor';
 import { SkillFileBatchError } from '@epam/ai-dial-skill-editor';
 import { SkillFileListResponseDto } from '@epam/ai-dial-chat-api-client';
+import { SkillFileSourceEntry } from '@epam/ai-dial-skill-editor';
 import { SkillFileTreeNode } from '@epam/ai-dial-skill-editor';
 import { SkillFileUploadCandidate } from '@epam/ai-dial-skill-editor';
 import { SkillFileValidationResult } from '@epam/ai-dial-skill-editor';
@@ -43,6 +44,16 @@ 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;
+
+/** Returns the limit each over-long skill field exceeds, keyed by field; fields within their limit are omitted. */
+export declare const getSkillFieldLengthViolations: (values: Record<SkillTextField, string>) => Partial<Record<SkillTextField, number>>;
+
 /**
  * Client-side mirror of the backend's `isValidSkillRelativePath`
  * (`apps/chat-api/src/skills/utils/skill-path.util.ts`), used only for
@@ -98,6 +109,9 @@ export declare const SKILL_FILE_UPLOAD_MAX_BYTES = 1048576;
 /** Root manifest filename required at the top of every skill archive (mirrors `SKILL_MANIFEST_FILE` in `apps/chat-api/src/skills/utils/skill-path.util.ts`). */
 export declare const SKILL_MANIFEST_FILE = "SKILL.md";
 
+/** Length limit of each skill editor text field. */
+export declare const SKILL_TEXT_FIELD_MAX_LENGTHS: Record<SkillTextField, number>;
+
 /**
  * Client-side mirror of the backend's default `SKILL_UPLOAD_MAX_FILES`
  * (`apps/chat-api/src/config/environment.config.ts`), used only for
@@ -122,6 +136,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 +199,14 @@ export declare interface SkillEditorSubmitClient {
 export declare interface SkillEditorSubmitMessages {
     /** Shown when a required field is empty. */
     required: string;
+    /** Shown when a name, description or instructions value exceeds its length limit, given that limit. */
+    tooLong: (maxLength: number) => 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 +372,31 @@ export declare interface SkillManifestValues {
     instructions: string;
 }
 
+/** Skill editor text fields with a length limit. */
+export declare type SkillTextField = 'name' | 'description' | 'instructions';
+
+/**
+ * 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 +415,48 @@ 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, abort-on-close, 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 the client. `signal` aborts when the dialog closes or the hook unmounts mid-upload. */
+    importArchive: (file: File, signal: AbortSignal) => 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;
+    /** Whether an import request is in flight; the dialog stays open until it succeeds. */
+    isUploading: boolean;
+    /** 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 and clears any previous rejection or request failure. */
+    openDialog: () => void;
+    /** Closes the dialog, aborting an in-flight import, 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 +508,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 +528,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 +550,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,15 +562,22 @@ 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;
 }
 
 /**
  * Owns the Skill Editor's batch file upload workflow: validating a staged
  * batch, committing it atomically (supporting files plus an optional
- * `SKILL.md` manifest import, with a confirmation gate), and removing
+ * `SKILL.md` manifest import, with a confirmation gate), creating empty
+ * folders, expanding `.zip` archives for staging, and removing
  * already-committed nodes.
  */
-export declare const useSkillFileActions: ({ files, setFiles, filesContentRef, frontmatterRef, loadedValues, setLoadedValues, isEditMode, isDirty, setSelectedPath, messages, }: UseSkillFileActionsParams) => UseSkillFileActionsResult;
+export declare const useSkillFileActions: ({ files, setFiles, filesContentRef, frontmatterRef, loadedValues, setLoadedValues, isEditMode, isDirty, setSelectedPath, messages, pickFromFileSystem, }: UseSkillFileActionsParams) => UseSkillFileActionsResult;
 
 /** Parameters accepted by {@link useSkillFileActions}. */
 export declare interface UseSkillFileActionsParams {
@@ -477,6 +601,12 @@ export declare interface UseSkillFileActionsParams {
     setSelectedPath: Dispatch<SetStateAction<string>>;
     /** Localized messages, resolved by the host. */
     messages: SkillFileActionsMessages;
+    /**
+     * Opens the host's file-system picker; passed through unchanged as
+     * `fileActions.pickFromFileSystem`. Omit to hide the editor's "Open DIAL
+     * file system" entry.
+     */
+    pickFromFileSystem?: () => Promise<SkillFileSourceEntry[] | undefined>;
 }
 
 /** Return value of {@link useSkillFileActions}. */

package/skill-editor.js

@@ -1,8 +1,9 @@
-import { SKILL_FILE_UPLOAD_MAX_BYTES as e, SKILL_MANIFEST_FILE as t, SKILL_UPLOAD_MAX_FILES as n, SKILL_UPLOAD_MAX_TOTAL_BYTES as r, buildSkillFilesPayload as i, buildSkillManifest as a, buildSkillManifestForSubmit as o, buildSkillManifestFromFrontmatter as s, isValidSkillRelativePath as c, nameFromPath as l, normalizeSkillName as u, parseSkillManifest as d, skillFileBytesToBlob as f, unpackSkillArchive as p } from "./skill/skill.js";
-import { parseSkillManifestDocument as m } from "./skill/skill-manifest.js";
-import { validateSkillFileBatch as h } from "./skill/skill-file-batch-validation.js";
-import { skillFileToAttachment as g } from "./skill/skill-file-preview.js";
-import { SkillEditorLoadState as _, useSkillEditorLoad as v } from "./skill/useSkillEditorLoad.js";
-import { useSkillEditorSubmit as y } from "./skill/useSkillEditorSubmit.js";
-import { useSkillFileActions as b } from "./skill/useSkillFileActions.js";
-export { e as SKILL_FILE_UPLOAD_MAX_BYTES, t as SKILL_MANIFEST_FILE, n as SKILL_UPLOAD_MAX_FILES, r as SKILL_UPLOAD_MAX_TOTAL_BYTES, _ as SkillEditorLoadState, i as buildSkillFilesPayload, a as buildSkillManifest, o as buildSkillManifestForSubmit, s as buildSkillManifestFromFrontmatter, c as isValidSkillRelativePath, l as nameFromPath, u as normalizeSkillName, d as parseSkillManifest, m as parseSkillManifestDocument, f as skillFileBytesToBlob, g as skillFileToAttachment, p as unpackSkillArchive, v as useSkillEditorLoad, y as useSkillEditorSubmit, b as useSkillFileActions, h as validateSkillFileBatch };
+import { SKILL_FILE_UPLOAD_MAX_BYTES as e, SKILL_MANIFEST_FILE as t, SKILL_TEXT_FIELD_MAX_LENGTHS as n, SKILL_UPLOAD_MAX_FILES as r, SKILL_UPLOAD_MAX_TOTAL_BYTES as i, buildSkillFilesPayload as a, buildSkillManifest as o, buildSkillManifestForSubmit as s, buildSkillManifestFromFrontmatter as c, getSkillFieldLengthViolations as l, isValidSkillRelativePath as u, nameFromPath as d, normalizeSkillName as f, parseSkillManifest as p, skillFileBytesToBlob as m, startsWithFrontmatterBlock as h, unpackSkillArchive as g } from "./skill/skill.js";
+import { parseSkillManifestDocument as _ } from "./skill/skill-manifest.js";
+import { validateSkillFileBatch as v } from "./skill/skill-file-batch-validation.js";
+import { skillFileToAttachment as y } from "./skill/skill-file-preview.js";
+import { SkillEditorLoadState as b, useSkillEditorLoad as x } from "./skill/useSkillEditorLoad.js";
+import { useSkillEditorSubmit as S } from "./skill/useSkillEditorSubmit.js";
+import { useSkillFileActions as C } from "./skill/useSkillFileActions.js";
+import { SkillArchiveImportErrorKind as w, SkillArchiveImportStatus as T, SkillArchiveSelectionRejectionReason as E, classifySkillArchiveImportError as D, useSkillArchiveImport as O } from "./skill/useSkillArchiveImport/useSkillArchiveImport.js";
+export { e as SKILL_FILE_UPLOAD_MAX_BYTES, t as SKILL_MANIFEST_FILE, n as SKILL_TEXT_FIELD_MAX_LENGTHS, r as SKILL_UPLOAD_MAX_FILES, i as SKILL_UPLOAD_MAX_TOTAL_BYTES, w as SkillArchiveImportErrorKind, T as SkillArchiveImportStatus, E as SkillArchiveSelectionRejectionReason, b as SkillEditorLoadState, a as buildSkillFilesPayload, o as buildSkillManifest, s as buildSkillManifestForSubmit, c as buildSkillManifestFromFrontmatter, D as classifySkillArchiveImportError, l as getSkillFieldLengthViolations, u as isValidSkillRelativePath, d as nameFromPath, f as normalizeSkillName, p as parseSkillManifest, _ as parseSkillManifestDocument, m as skillFileBytesToBlob, y as skillFileToAttachment, h as startsWithFrontmatterBlock, g as unpackSkillArchive, O as useSkillArchiveImport, x as useSkillEditorLoad, S as useSkillEditorSubmit, C as useSkillFileActions, v as validateSkillFileBatch };