tauri-kargo-tools 0.2.0 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tauri-kargo-tools",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "",
    "files": ["src"],
  "exports": { "./*": "./src/*" },

package/src/api.ts

@@ -185,8 +185,8 @@ async writeFileBinary(
   /* =============== Routes: Explorer =============== */
 
   /** POST /api/explorer */
-  explorer(body: T.ExplorerReq): Promise<T.ExplorerResult> {
-    return this.postJson<T.ExplorerResult>("/api/explorer", body);
+  explorer(body: T.ExplorerRequest): Promise<T.ExplorerResponse> {
+    return this.postJson<T.ExplorerResponse>("/api/explorer", body);
   }
 
   /* =============== Routes: Servers =============== */

package/src/schema/base.ts

@@ -0,0 +1,497 @@
+export type Type<T> =
+
+  | "string"
+
+  | "number"
+
+  | "boolean"
+
+  | { union: readonly string[]; }
+
+  | { ref: readonly (keyof T)[]; }
+
+
+
+  | { arrayOf: Type<T>; }
+
+  | { optional: Type<T>; };
+
+
+
+export type Structure<T> = { [name: string]: Type<T>; };
+export type EntityFieldValue = number | string | boolean | { ref: string } | EntityFieldValue[]
+export type Entity = { [name: string]: EntityFieldValue }
+export type EntityMap = { [id: string]: Entity }
+
+export function createModel<T extends { [name: string]: Structure<T>; }>(def: T): T {
+  return def;
+}
+
+
+
+export class DataModel<T extends { [name: string]: Structure<T>; }> {
+
+  def: T;
+
+  map: { [id: string]: ModelElement<T>; } = {};
+  types: { [id: string]: keyof T } = {}
+  idx = 0;
+  idForModelElement: Map<ModelElement<T>, string>;
+  constructor(def: T) {
+    this.idForModelElement = new Map()
+    this.def = def;
+
+  }
+  getValues(): ModelElement<T>[] {
+    return Object.values(this.map)
+  }
+
+  getValue(ref: string): ModelElement<T> {
+    return this.map[ref];
+  }
+
+  is<K extends keyof T>(m: any, type: K): m is Interfaces<T>[K] {
+    const id = this.idForModelElement.get(m)
+    if (!id) {
+      return false
+    }
+    return this.types[id] === type
+
+  }
+  isRef<K extends keyof T>(ref: any, type: K): ref is Ref<T, K> {
+    if (typeof ref.ref !== "string") {
+      return false
+    }
+    const value = this.getValue(ref.ref)
+    if (ref.ref && this.is(value, type)) {
+      ref.getValue = () => value
+      return true
+    }
+    return false
+
+  }
+  initField(ref: string, name: string, value: EntityFieldValue) {
+    const entity = this.map[ref]
+    if (entity) {
+      const type = this.types[ref]
+      const typeField = this.def[type][name]
+      if (this.checkType(typeField, this.map, value, {})) {
+        (entity as any)[name] = value
+      }
+    }
+
+
+  }
+
+  init(value: EntityMap) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined;
+
+    const map: { [id: string]: keyof T } = {};
+
+    for (const id in value) {
+      let ok = false;
+
+      for (const t in this.def) {
+        if (this.check(id, value, t as keyof T, map)) {
+          ok = true;
+          break;
+        }
+      }
+
+      if (!ok) return undefined; // ou throw new Error(`No type matches for ${id}`)
+    }
+    this.map = value as any
+    for (let e of Object.entries(this.map)) {
+      this.idForModelElement.set(e[1], e[0])
+    }
+    this.types = map
+
+    return map;
+  }
+
+
+  check<K extends keyof T>(id: string, value: any, type: K, map: { [id: string]: keyof T }): boolean {
+    if (map[id] === type) {
+      return true
+    }
+    if (map[id] !== undefined) {
+      return false
+    }
+
+
+    map[id] = type
+    const struct = this.def[type]
+    if (this.checkStructure(struct, value, value[id], map)) {
+      return true
+    }
+    delete map[id]
+    return false
+
+
+  }
+  checkStructure(
+    struct: Structure<T>,
+    value: any,
+    obj: any,
+    map: { [id: string]: keyof T }
+  ): boolean {
+    if (typeof obj !== "object" || obj === null || Array.isArray(obj)) return false;
+
+    // mode strict : pas de propriétés inconnues
+    for (const k of Object.keys(obj)) {
+      if (!(k in struct)) return false;
+    }
+
+    for (const [prop, t] of Object.entries(struct)) {
+      const v = (obj as any)[prop];
+
+      // optional
+      if (this.isOptionalType(t)) {
+        if (v === undefined) continue;
+        if (!this.checkType(t.optional, value, v, map)) return false;
+        continue;
+      }
+
+      // required
+      if (v === undefined) return false;
+      if (!this.checkType(t as Type<T>, value, v, map)) return false;
+    }
+
+    return true;
+  }
+
+  private checkType(
+    t: Type<T>,
+    root: any, // le "value" global (map d'objets)
+    v: any,
+    map: { [id: string]: keyof T }
+  ): boolean {
+    if (t === "string") return typeof v === "string";
+    if (t === "number") return typeof v === "number";
+    if (t === "boolean") return typeof v === "boolean";
+
+    if (this.isUnionType(t)) {
+      return typeof v === "string" && t.union.includes(v);
+    }
+
+    if (this.isArrayOfType(t)) {
+      return Array.isArray(v) && v.every(el => this.checkType(t.arrayOf, root, el, map));
+    }
+
+    if (this.isOptionalType(t)) {
+      return v === undefined || this.checkType(t.optional, root, v, map);
+    }
+
+    if (this.isRefType(t)) {
+      // runtime minimal : { ref: "$0" }
+      if (typeof v !== "object" || v === null || Array.isArray(v)) return false;
+      const rid = (v as any).ref;
+
+      if (typeof rid !== "string") return false;
+      if (!(rid in root)) return false;
+
+      // doit matcher AU MOINS un type autorisé
+      const allowed = t.ref as readonly (keyof T)[];
+      for (const candidate of allowed) {
+        if (this.check(rid, root, candidate, map)) {
+          (v as any).getValue = () => root[rid]
+          return true;
+        }
+      }
+      return false;
+    }
+
+    return false;
+  }
+
+  private isUnionType(x: any): x is { union: readonly string[] } {
+    return typeof x === "object" && x !== null && Array.isArray(x.union);
+  }
+  private isRefType(x: any): x is { ref: readonly (keyof T)[] } {
+    return typeof x === "object" && x !== null && Array.isArray(x.ref);
+  }
+  private isArrayOfType(x: any): x is { arrayOf: Type<T> } {
+    return typeof x === "object" && x !== null && "arrayOf" in x;
+  }
+  private isOptionalType(x: any): x is { optional: Type<T> } {
+    return typeof x === "object" && x !== null && "optional" in x;
+  }
+
+
+  createValue<K extends keyof T>(type: K, value: Interfaces<T>[K]): Ref<T, K> {
+
+    const ref = `$${this.idx}`;
+
+    this.idx++;
+
+    this.map[ref] = value as any;
+    this.types[ref] = type
+    this.idForModelElement.set(this.map[ref], ref)
+
+    return { ref: ref, getValue: () => value } as any;
+
+  }
+
+
+
+
+}
+
+export type RefUnion<TDefs extends { [name: string]: Structure<TDefs>; }> = {
+  [K in keyof TDefs]: Ref<TDefs, K>;
+}[keyof TDefs];
+
+type UnwrapOptional<V> = V extends { optional: infer O; } ? O : V;
+
+export type Ref<TDefs extends { [name: string]: Structure<TDefs>; }, K extends keyof TDefs> = { ref: string, getValue(): Interfaces<TDefs>[K] }
+
+// Résout un champ du DSL vers un type TypeScript concret
+
+type ToTsType<
+
+  TDefs extends { [name: string]: Structure<TDefs>; },
+
+  V
+
+> =
+
+  V extends "string" ? string :
+
+  V extends "number" ? number :
+
+  V extends "boolean" ? boolean :
+
+  V extends { ref: infer K; }
+
+  ? K extends readonly (keyof TDefs)[]
+
+  ? { [U in K[number]]: Ref<TDefs, U> }[K[number]]
+
+  : never
+
+  : V extends { arrayOf: infer O; }
+
+  ? ToTsType<TDefs, O>[]
+
+  : V extends { optional: infer O; }
+
+  ? ToTsType<TDefs, O>
+
+  : V extends { union: infer L; }
+
+  ? L extends readonly string[]
+
+  ? L[number]
+
+  : never
+
+  : never;
+
+
+
+// Matérialise une "entité" (clé de TDefs) en interface concrète
+
+export type ToInterface<
+
+  TDefs extends { [name: string]: Structure<TDefs>; },
+
+  Name extends keyof TDefs
+
+> =
+
+  // Propriétés requises (pas 'optional')
+
+  {
+    -readonly [P in keyof TDefs[Name]as TDefs[Name][P] extends { optional: any; } ? never : P]:
+
+    ToTsType<TDefs, TDefs[Name][P]>;
+
+  }
+
+  &
+
+  // Propriétés optionnelles ('optional')
+
+  {
+
+    -readonly [P in keyof TDefs[Name]as TDefs[Name][P] extends { optional: any; } ? P : never]?:
+
+    ToTsType<TDefs, UnwrapOptional<TDefs[Name][P]>>;
+
+  };
+
+// Matérialise l’ensemble des interfaces
+
+type Interfaces<TDefs extends { [name: string]: Structure<TDefs>; }> = {
+
+  [K in keyof TDefs]: ToInterface<TDefs, K>;
+
+};
+
+type ModelElement<TDefs extends { [name: string]: Structure<TDefs>; }> = Interfaces<TDefs>[keyof TDefs];
+
+
+
+type Def<TDefs> = { [name: string]: Structure<TDefs> };
+
+export class TypeImplicationChecker<TDefs extends Def<TDefs>> {
+  constructor(public readonly def: TDefs) { }
+
+  /** Calcule la matrice implies[A][B] (point fixe) et la liste des incohérences A⇒B (A≠B). */
+  analyze() {
+    const names = Object.keys(this.def) as (keyof TDefs & string)[];
+    const implies: Record<string, Record<string, boolean>> = {};
+
+    for (const a of names) {
+      implies[a] = {};
+      for (const b of names) implies[a][b] = (a === b);
+    }
+
+    let changed = true;
+    while (changed) {
+      changed = false;
+
+      for (const a of names) {
+        for (const b of names) {
+          if (a === b) continue;
+          if (implies[a][b]) continue;
+
+          if (this.impliesStructure(a, b, implies)) {
+            implies[a][b] = true;
+            changed = true;
+          }
+        }
+      }
+    }
+
+    const problems: Array<{ A: string; B: string }> = [];
+    for (const a of names) {
+      for (const b of names) {
+        if (a !== b && implies[a][b]) problems.push({ A: a, B: b });
+      }
+    }
+
+    return { implies, problems };
+  }
+
+  /** Vrai si le système est cohérent au sens “aucun A⇒B avec A≠B”. */
+  isCoherent(): boolean {
+    return this.analyze().problems.length === 0;
+  }
+
+  /** Lève une erreur si incohérent. */
+  assertCoherent(): void {
+    const { problems } = this.analyze();
+    if (problems.length) {
+      const msg = problems.map(p => `${p.A} => ${p.B}`).join(", ");
+      throw new Error(`Incoherent type system (implications found): ${msg}`);
+    }
+  }
+
+  // ----------------- Implémentation interne -----------------
+
+  private isUnion(x: any): x is { union: readonly string[] } {
+    return typeof x === "object" && x !== null && Array.isArray(x.union);
+  }
+  private isRef(x: any): x is { ref: readonly string[] } {
+    return typeof x === "object" && x !== null && Array.isArray(x.ref);
+  }
+  private isArrayOf(x: any): x is { arrayOf: any } {
+    return typeof x === "object" && x !== null && "arrayOf" in x;
+  }
+  private isOptional(x: any): x is { optional: any } {
+    return typeof x === "object" && x !== null && "optional" in x;
+  }
+
+  private impliesType(a: Type<TDefs>, b: Type<TDefs>, implies: Record<string, Record<string, boolean>>): boolean {
+    // primitives
+    if (a === "string") return b === "string";
+    if (a === "number") return b === "number";
+    if (a === "boolean") return b === "boolean";
+
+    // union
+    if (this.isUnion(a)) {
+      if (b === "string") return true; // union de literals ⊆ string
+      if (!this.isUnion(b)) return false;
+      const A = new Set(a.union);
+      return b.union.every(x => A.has(x)); // A ⊆ B  => union(A) ⇒ union(B)
+    }
+
+    // optional
+    if (this.isOptional(a)) {
+      if (!this.isOptional(b)) return false; // optional(X) ne peut pas impliquer Y (undefined possible)
+      return this.impliesType(a.optional, b.optional, implies);
+    }
+    if (this.isOptional(b)) {
+      // X ⇒ optional(Y) si X⇒Y
+      return this.impliesType(a, b.optional, implies);
+    }
+
+    // arrayOf
+    if (this.isArrayOf(a)) {
+      if (!this.isArrayOf(b)) return false;
+      return this.impliesType(a.arrayOf, b.arrayOf, implies);
+    }
+
+    // ref
+    if (this.isRef(a)) {
+      if (!this.isRef(b)) return false;
+      // {ref:[A1..]} ⇒ {ref:[B1..]} si ∀Ai ∃Bj : Ai ⇒ Bj
+      return a.ref.every(ai => b.ref.some(bj => implies[String(ai)]?.[String(bj)] === true));
+    }
+
+    return false;
+  }
+
+  /**
+   * Structure-level implication A⇒B en mode STRICT (comme votre checkStructure):
+   * - un objet A ne doit pas avoir de propriété inconnue pour B
+   * - les requis de B doivent être requis dans A
+   * - les types doivent impliquer
+   */
+  private impliesStructure(
+    A: keyof TDefs & string,
+    B: keyof TDefs & string,
+    implies: Record<string, Record<string, boolean>>
+  ): boolean {
+    const SA = this.def[A];
+    const SB = this.def[B];
+
+    // STRICT: toutes les props de A doivent exister dans B (sinon un objet A échoue chez B)
+    for (const p in SA) {
+      if (!(p in SB)) return false;
+    }
+
+    for (const p in SB) {
+      const tb = SB[p];
+      const ta = SA[p];
+
+      const bOpt = this.isOptional(tb);
+      const aOpt = ta !== undefined ? this.isOptional(ta) : false;
+
+      if (!bOpt) {
+        // B requiert p => A doit le requérir aussi
+        if (ta === undefined) return false;
+        if (aOpt) return false;
+        if (!this.impliesType(ta, tb, implies)) return false;
+      } else {
+        // B optionnel : A peut ne pas avoir p ; si A l'a, il doit impliquer le noyau de B
+        if (ta === undefined) continue;
+        const taCore = aOpt ? (ta as any).optional : ta;
+        const tbCore = (tb as any).optional;
+        if (!this.impliesType(taCore, tbCore, implies)) return false;
+      }
+    }
+
+    return true;
+  }
+}
+
+export interface DataModelReponse {
+  type: 'dataModelReponse';
+  value: any;
+}
+export interface RefReponse {
+  type: 'refReponse';
+  ref: string;
+}

package/src/schema/client.ts

@@ -0,0 +1,62 @@
+import { Ref, Structure, ToInterface, DataModel, RefUnion } from "./base";
+export type KeysOfType<T, V> = { [K in keyof T]-?: T[K] extends V ? K : never }[keyof T];
+export type Value = string | number | boolean | Value[]
+export interface DataModelProp<T extends { [name: string]: Structure<T>; }, K extends keyof T, F extends keyof ToInterface<T, K>> {
+  ref: Ref<T, K>
+  field: F
+  value: ToInterface<T, K>[F]
+}
+export interface SetDataModelProp<T extends { [name: string]: Structure<T>; }, K extends keyof T, F extends keyof ToInterface<T, K>> extends DataModelProp<T, K, F> {
+  type: "setDataModelProp"
+}
+
+export class DataModelClient<T extends { [name: string]: Structure<T>; }> {
+  def: T;
+  resolveDataModel: (dm: DataModel<T>) => void = () => { };
+  resolveRefUnion: (ref: RefUnion<T>) => void = () => { };
+
+  async setProp<K extends keyof T, F extends KeysOfType<ToInterface<T, K>, Value>>(dvp: DataModelProp<T, K, F>): Promise<DataModel<T>> {
+    const setDataModelProp: SetDataModelProp<T, K, F> = { ...dvp, type: "setDataModelProp" }
+    self.postMessage(JSON.parse(JSON.stringify(setDataModelProp)))
+
+    const r = new Promise<DataModel<T>>((resolve) => {
+      this.resolveDataModel = resolve;
+    })
+    return r;
+
+  }
+  async getDataModel(): Promise<DataModel<T>> {
+    self.postMessage({ type: "getDataModel" })
+    const r = new Promise<DataModel<T>>((resolve) => {
+      this.resolveDataModel = resolve;
+    })
+    return r;
+  }
+  async getSelf() {
+    self.postMessage({ type: "getSelf" })
+    const r = new Promise<RefUnion<T>>((resolve) => {
+      this.resolveRefUnion = resolve;
+    })
+    return r;
+
+
+  }
+  constructor(def: T) {
+    this.def = def;
+    self.addEventListener("message", (event) => {
+      const data = event.data;
+      if (data.type === "refReponse") {
+        const refReponse = data as { type: 'refReponse', ref: string };
+        const r = { ref: refReponse.ref } as RefUnion<T>;
+        this.resolveRefUnion(r);
+        return;
+      }
+      if (data.type === "dataModelReponse") {
+        const r = new DataModel<T>(this.def)
+        r.init(data.value)
+        this.resolveDataModel(r);
+      }
+
+    })
+  }
+}

package/src/schema/server.ts

@@ -0,0 +1,44 @@
+import { set } from "../container";
+import { Ref, Structure, ToInterface, DataModel, DataModelReponse, RefUnion } from "./base";
+import { Value } from "./client";
+
+export interface SetDataModelProp {
+    type: "setDataModelProp",
+    ref: { ref: string }
+    field: string
+    value: Value
+}
+export interface SimpleRef {
+    ref: string
+}
+
+export class DataModelServer<T extends { [name: string]: Structure<T>; }> extends DataModel<T> {
+
+    constructor(def: T) {
+        super(def)
+    }
+    process(worker: Worker, check: (setDataModelProp: SetDataModelProp) => boolean, ref:SimpleRef) {
+        worker.addEventListener("message", async (event) => {
+            const data = event.data;
+            if (data.type === "setDataModelProp") {
+                const setDataModelProp = data as SetDataModelProp;
+                if (check(setDataModelProp)) {
+                    this.initField(setDataModelProp.ref.ref, setDataModelProp.field, setDataModelProp.value);
+                    worker.postMessage(this.cloneMap());
+                }
+            }
+            if (data.type === "getDataModel") {
+                worker.postMessage(this.cloneMap());
+            }
+            if (data.type === "getSelf") {
+                const refReponse = { type: 'refReponse', ref: ref.ref };
+                worker.postMessage(refReponse);
+            }
+        })
+
+    }
+    cloneMap(): DataModelReponse {
+        return { type: 'dataModelReponse', value: JSON.parse(JSON.stringify(this.map)) };
+    }
+
+}

package/src/test/data-model.ts

@@ -0,0 +1,13 @@
+import { createModel } from "../schema/base";
+
+
+export const model = createModel({
+    Cell: {
+        nom: "string",
+        state: "boolean",
+    },
+    Groupe: {
+        state:"boolean",
+        membres: { arrayOf: { ref: ["Cell"] } }
+    }
+})

package/src/test/index.ts

@@ -1,5 +1,96 @@
 import * as test from "../test"
 import * as api from '../api'
+import * as schema from "../schema/base"
+import { DataModelServer, SetDataModelProp } from "../schema/server"
+import { model } from "./data-model"
+test.test("Test schema client server", async () => {
+
+    const server = new DataModelServer(model)
+    const state = server.createValue("Cell", { nom: "A", state: false })
+    const groupe = server.createValue("Groupe", { membres: [state], state: false })
+    let resolve: (b: SetDataModelProp[]) => void = () => { }
+    const p = new Promise<SetDataModelProp[]>((r) => {
+        resolve = r
+    })
+    const m: SetDataModelProp[] = []
+    const worker = new Worker(new URL("./worker.ts", import.meta.url), { type: "module" });
+    server.process(worker, (op) => {
+        m.push(op)
+        if (m.length >= 2) {
+            resolve(m)
+        }
+        return true
+    }, groupe)
+    const v = await p
+    test.assertEquals(v[0].ref.ref === (state.ref as any), true)
+    test.assertEquals(v[1].ref.ref === (groupe.ref as any), true)
+    worker.terminate()
+
+})
+test.test("Test schema simple un type", async () => {
+    const vue = new schema.DataModel({
+        Point: {
+            x: "number",
+            y: "number"
+        }
+    })
+    const p = vue.createValue("Point", { x: 10, y: 15 })
+    test.assertEquals(p.getValue().x, 10)
+    test.assertEquals(p.getValue().y, 15)
+    const anotherVue = new schema.DataModel({
+        Point: {
+            x: "number",
+            y: "number"
+        }
+    })
+    const copy = JSON.parse(JSON.stringify(vue.map))
+    const map = anotherVue.init(copy)
+    test.assertEquals(map !== undefined, true)
+    test.assertEquals(map![p.ref], "Point")
+    const p2 = anotherVue.getValue(p.ref)
+    test.assertEquals(p2.x, 10)
+    test.assertEquals(p2.y, 15)
+    console.log(map)
+
+
+
+})
+
+test.test("Test schema simple avec deux type", async () => {
+    const vue = new schema.DataModel({
+        Point: {
+            x: "number",
+            y: "number"
+        },
+        Personne: {
+            nom: "string",
+            prenom: "string"
+        }
+    })
+    const point = vue.createValue("Point", { x: 10, y: 15 })
+    const personne = vue.createValue("Personne", { nom: "Toto", prenom: "Lili" })
+    let testPoint = false
+    let testPersonne = false
+    for (const p of vue.getValues()) {
+        if (vue.is(p, "Point")) {
+            test.assertEquals(p.x, 10)
+            test.assertEquals(p.y, 15)
+            testPoint = true
+        }
+        if (vue.is(p, "Personne")) {
+            test.assertEquals(p.nom, "Toto")
+            test.assertEquals(p.prenom, "Lili")
+            testPersonne = true
+        }
+    }
+    test.assertEquals(testPoint, true)
+    test.assertEquals(testPersonne, true)
+
+
+
+
+
+})
 test.test("Test read file", async () => {
 
     const client = api.createClient();
@@ -35,7 +126,8 @@ test.test("Test read file", async () => {
 
         }), false, "pas dans rep")
     }
-
+    rep = await client.explorer({ type: "array", path: "C:/Users/david/Documents/GitHub/tauriKargoExamples/examples/test-api-file-typescript" })
+    console.log(rep)
 
 
 

package/src/test/worker.ts

@@ -0,0 +1,27 @@
+import { DataModelClient } from "../schema/client"
+import { model } from "./data-model"
+
+
+const client = new DataModelClient(model);
+
+
+(async () => {
+    const dm = await client.getDataModel();
+    for (const o of dm.getValues()) {
+        if (dm.is(o, "Groupe")) {
+            for (const ref of o.membres) {
+                console.log(dm.map)
+                const tmp = await client.setProp({ ref: ref, field: "state", value: true });
+                console.log(tmp.map)
+            }
+
+
+        }
+    }
+    const selfRef = await client.getSelf();
+    if (dm.isRef(selfRef, "Groupe")) {
+        await client.setProp({ ref: selfRef, field: "state", value: true });
+    }
+
+
+})()

package/src/types.ts

@@ -104,29 +104,86 @@ export interface StopAllResp {
 export interface ExplorerReq {
   path?: string;
 }
+// api-explorer
+// =====================
+// /api/explorer - types
+// =====================
 
-export type ExplorerElement = ExplorerDirectory | ExplorerFile
+export type ExplorerMode = "array" | "tree";
 
-export interface ExplorerFile {
+export type ExplorerRequest = {
+  /** vide => CWD côté serveur ; relatif => CWD+rel ; absolu => tel quel */
+  path?: string;
+
+  /** "array" => content = fichiers à plat ; "tree" => content = arborescence */
+  type?: ExplorerMode;
+
+  /** profondeur max (enfants directs = 1). Si absent et type absent => default serveur: 1 */
+  maxDeep?: number;
+
+  /** nombre max de fichiers retournés (limite globale) */
+  maxSize?: number;
+};
+
+// ---- réponses ----
+
+export type ExplorerErrorResponse = {
+  type: "error";
+  message: string;
+};
+
+export type ExplorerFileResponse = {
   type: "file";
+  /** chemin absolu (format "joli" Windows/UNC si applicable) */
   path: string;
   name: string;
+  /** chemin absolu du parent ou null si racine */
   parent: string | null;
-}
+};
 
-export interface ExplorerDirectory {
-  type: "directory";
-  name:string;
+export type ExplorerArrayFileItem = {
+  type:'file'
+  name: string;
+  /** chemin absolu du fichier */
   path: string;
-  parent: string | null;
-  content: ExplorerElement[];
-}
-
-export interface ExplorerError {
-  type: "error";
-  message: string;
-}
-
+};
+
+export type ExplorerTreeItem =
+  | {
+      type: "file";
+      name: string;
+      path: string; // absolu
+    }
+  | {
+      type: "directory";
+      name: string;
+      path: string; // absolu
+      /** peut être absent si maxDeep empêche d'expand */
+      content?: ExplorerTreeItem[];
+    };
+
+export type ExplorerDirectoryResponse =
+  | {
+      type: "directory";
+      path: string; // absolu
+      parent: string | null;
+      /** si request.type === "array" */
+      content: ExplorerArrayFileItem[];
+    }
+  | {
+      type: "directory";
+      path: string; // absolu
+      parent: string | null;
+      /** si request.type === "tree" (ou mode absent côté compat) */
+      content: ExplorerTreeItem[];
+    };
+
+export type ExplorerResponse =
+  | ExplorerErrorResponse
+  | ExplorerFileResponse
+  | ExplorerDirectoryResponse;
+
+//
 export interface NewServerReq {
   code: string;
   executable: string;
@@ -156,10 +213,7 @@ export interface StopServerResp {
    ========================= */
 
 /** Result of /api/explorer (200) */
-export type ExplorerResult = ExplorerFile | ExplorerDirectory;
 
-/** Error shapes from /api/explorer (404/500) */
-export type ExplorerErrorResult = ExplorerError;
 
 /* =========================
    (Optionnel) Types d’IO par route