@unrdf/hooks 5.0.1 → 26.4.2

package/dist/index.d.ts

@@ -0,0 +1,1738 @@
+import { z } from 'zod';
+import { dataFactory } from '@unrdf/oxigraph';
+
+const HookTriggerSchema = z.enum([
+  // Core CRUD (6)
+  "before-add",
+  "after-add",
+  "before-query",
+  "after-query",
+  "before-remove",
+  "after-remove",
+  // Transaction Hooks (4)
+  "before-commit",
+  "after-commit",
+  "before-rollback",
+  "after-rollback",
+  // Error/Event Hooks (5)
+  "on-error",
+  "on-validation-fail",
+  "on-transform",
+  "on-timeout",
+  "on-circuit-open",
+  // Async/IO Hooks (6)
+  "before-fetch",
+  "after-fetch",
+  "before-sync",
+  "after-sync",
+  "before-import",
+  "after-import",
+  // Cron/Time Hooks (4)
+  "on-schedule",
+  "on-interval",
+  "on-idle",
+  "on-startup",
+  // Lean Six Sigma Quality Hooks (8)
+  "quality-gate",
+  "defect-detection",
+  "continuous-improvement",
+  "spc-control",
+  "capability-analysis",
+  "root-cause",
+  "kaizen-event",
+  "audit-trail"
+]);
+const HookConfigSchema = z.object({
+  name: z.string().min(1, "Hook name is required"),
+  trigger: HookTriggerSchema,
+  // Note: No return type enforcement - runtime POKA-YOKE guard handles non-boolean returns
+  validate: z.function().optional(),
+  transform: z.function().optional(),
+  metadata: z.record(z.string(), z.any()).optional()
+});
+const HookSchema = z.object({
+  name: z.string(),
+  trigger: HookTriggerSchema,
+  validate: z.function().optional(),
+  transform: z.function().optional(),
+  metadata: z.record(z.string(), z.any()).optional()
+});
+function defineHook(config) {
+  const validated = HookConfigSchema.parse(config);
+  if (!validated.validate && !validated.transform) {
+    throw new Error("Hook must define either validate or transform function");
+  }
+  return {
+    name: validated.name,
+    trigger: validated.trigger,
+    validate: validated.validate,
+    transform: validated.transform,
+    metadata: validated.metadata || {},
+    // Pre-computed flags for sub-1μs execution (skip Zod in hot path)
+    _hasValidation: typeof validated.validate === "function",
+    _hasTransformation: typeof validated.transform === "function",
+    _validated: true
+  };
+}
+function isValidHook(hook) {
+  try {
+    HookSchema.parse(hook);
+    return hook.validate !== void 0 || hook.transform !== void 0;
+  } catch {
+    return false;
+  }
+}
+function getHookMetadata(hook, key) {
+  const validated = HookSchema.parse(hook);
+  return validated.metadata?.[key];
+}
+function hasValidation$1(hook) {
+  if (hook._validated) {
+    return hook._hasValidation;
+  }
+  return typeof hook.validate === "function";
+}
+function hasTransformation$1(hook) {
+  if (hook._validated) {
+    return hook._hasTransformation;
+  }
+  return typeof hook.transform === "function";
+}
+
+const HookResultSchema = z.object({
+  valid: z.boolean(),
+  quad: z.any().optional(),
+  error: z.string().optional(),
+  hookName: z.string()
+});
+const ChainResultSchema = z.object({
+  valid: z.boolean(),
+  quad: z.any(),
+  results: z.array(HookResultSchema),
+  error: z.string().optional()
+});
+function executeHook(hook, quad, options = {}) {
+  const validatedHook = hook._validated ? hook : HookSchema.parse(hook);
+  const result = {
+    valid: true,
+    quad,
+    hookName: validatedHook.name
+  };
+  try {
+    if (hasValidation$1(validatedHook)) {
+      const validationResult = validatedHook.validate(quad);
+      if (typeof validationResult !== "boolean") {
+        console.warn(
+          `[POKA-YOKE] Hook "${validatedHook.name}": validate() returned ${typeof validationResult}, expected boolean. Coercing to boolean.`
+        );
+        result.warning = `Non-boolean validation return (${typeof validationResult}) coerced to boolean`;
+      }
+      if (!validationResult) {
+        result.valid = false;
+        result.error = `Validation failed for hook: ${validatedHook.name}`;
+        return result;
+      }
+    }
+    if (hasTransformation$1(validatedHook)) {
+      const transformed = validatedHook.transform(quad);
+      if (!transformed || typeof transformed !== "object") {
+        throw new TypeError(
+          `Hook "${validatedHook.name}": transform() must return a Quad object, got ${typeof transformed}`
+        );
+      }
+      if (!transformed.subject || !transformed.predicate || !transformed.object) {
+        throw new TypeError(
+          `Hook "${validatedHook.name}": transform() returned object missing subject/predicate/object`
+        );
+      }
+      if (transformed._pooled && options.warnPooledQuads !== false) {
+        console.warn(
+          `[POKA-YOKE] Hook "${validatedHook.name}": returned pooled quad. Clone before storing to prevent memory issues.`
+        );
+        result.warning = "Pooled quad returned - consider cloning";
+      }
+      result.quad = transformed;
+    }
+    return result;
+  } catch (error) {
+    result.valid = false;
+    result.error = error instanceof Error ? error.message : String(error);
+    result.errorDetails = {
+      hookName: validatedHook.name,
+      hookTrigger: validatedHook.trigger,
+      stack: error instanceof Error ? error.stack : void 0,
+      originalError: error instanceof Error ? error : void 0,
+      rawError: !(error instanceof Error) ? error : void 0
+    };
+    return result;
+  }
+}
+function executeHookChain(hooks, quad) {
+  const results = [];
+  let currentQuad = quad;
+  let chainValid = true;
+  let chainError = void 0;
+  for (const hook of hooks) {
+    const result = executeHook(hook, currentQuad);
+    results.push(result);
+    if (!result.valid) {
+      chainValid = false;
+      chainError = result.error;
+      break;
+    }
+    if (result.quad) {
+      currentQuad = result.quad;
+    }
+  }
+  return {
+    valid: chainValid,
+    quad: currentQuad,
+    results,
+    error: chainError
+  };
+}
+function executeHooksByTrigger(hooks, trigger, quad) {
+  const matchingHooks = hooks.filter((h) => h.trigger === trigger);
+  return executeHookChain(matchingHooks, quad);
+}
+function wouldPassHooks(hooks, quad) {
+  const result = executeHookChain(hooks, quad);
+  return result.valid;
+}
+function validateOnly(hooks, quad) {
+  for (const hook of hooks) {
+    if (hasValidation$1(hook)) {
+      try {
+        if (!hook.validate(quad)) {
+          return {
+            valid: false,
+            quad,
+            error: `Validation failed for hook: ${hook.name}`,
+            hookName: hook.name
+          };
+        }
+      } catch (error) {
+        return {
+          valid: false,
+          quad,
+          error: error instanceof Error ? error.message : String(error),
+          hookName: hook.name
+        };
+      }
+    }
+  }
+  return { valid: true, quad, hookName: "validateOnly" };
+}
+function executeBatch(hooks, quads, options = {}) {
+  const { stopOnError = false } = options;
+  const results = [];
+  let validCount = 0;
+  let invalidCount = 0;
+  for (let i = 0; i < quads.length; i++) {
+    const quad = quads[i];
+    let currentQuad = quad;
+    let isValid = true;
+    let error;
+    for (const hook of hooks) {
+      if (hasValidation$1(hook)) {
+        try {
+          if (!hook.validate(currentQuad)) {
+            isValid = false;
+            error = `Validation failed: ${hook.name}`;
+            break;
+          }
+        } catch (e) {
+          isValid = false;
+          error = e instanceof Error ? e.message : String(e);
+          break;
+        }
+      }
+      if (isValid && hasTransformation$1(hook)) {
+        try {
+          currentQuad = hook.transform(currentQuad);
+        } catch (e) {
+          isValid = false;
+          error = e instanceof Error ? e.message : String(e);
+          break;
+        }
+      }
+    }
+    results.push({ valid: isValid, quad: currentQuad, error, results: [] });
+    if (isValid) {
+      validCount++;
+    } else {
+      invalidCount++;
+      if (stopOnError) break;
+    }
+  }
+  return { results, validCount, invalidCount };
+}
+function validateBatch(hooks, quads) {
+  const validationHooks = hooks.filter(hasValidation$1);
+  const bitmap = new Uint8Array(quads.length);
+  for (let i = 0; i < quads.length; i++) {
+    const quad = quads[i];
+    let isValid = true;
+    for (const hook of validationHooks) {
+      try {
+        if (!hook.validate(quad)) {
+          isValid = false;
+          break;
+        }
+      } catch {
+        isValid = false;
+        break;
+      }
+    }
+    bitmap[i] = isValid ? 1 : 0;
+  }
+  return bitmap;
+}
+function transformBatch(hooks, quads, options = {}) {
+  const { validateFirst = true } = options;
+  const transformed = [];
+  const errors = [];
+  for (let i = 0; i < quads.length; i++) {
+    let currentQuad = quads[i];
+    let hasError = false;
+    for (const hook of hooks) {
+      try {
+        if (validateFirst && hasValidation$1(hook)) {
+          if (!hook.validate(currentQuad)) {
+            errors.push({ index: i, error: `Validation failed: ${hook.name}` });
+            hasError = true;
+            break;
+          }
+        }
+        if (hasTransformation$1(hook)) {
+          currentQuad = hook.transform(currentQuad);
+        }
+      } catch (error) {
+        errors.push({
+          index: i,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        hasError = true;
+        break;
+      }
+    }
+    if (!hasError) {
+      transformed.push(currentQuad);
+    }
+  }
+  return { transformed, errors };
+}
+const hookValidationCache = /* @__PURE__ */ new WeakMap();
+function clearHookCaches() {
+}
+function prewarmHookCache(hooks) {
+  const errors = [];
+  let prewarmed = 0;
+  for (const hook of hooks) {
+    try {
+      HookSchema.parse(hook);
+      hookValidationCache.set(hook, true);
+      prewarmed++;
+    } catch (error) {
+      errors.push(
+        `Hook "${hook?.name || "unknown"}": ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  return { prewarmed, errors };
+}
+
+const compiledChains = /* @__PURE__ */ new Map();
+let jitAvailable = true;
+try {
+  new Function("return true")();
+} catch {
+  jitAvailable = false;
+}
+function hasValidation(hook) {
+  return typeof hook.validate === "function";
+}
+function hasTransformation(hook) {
+  return typeof hook.transform === "function";
+}
+function getChainKey(hooks) {
+  return hooks.map((h) => h.name).join("|");
+}
+function compileHookChain(hooks) {
+  const chainKey = getChainKey(hooks);
+  if (compiledChains.has(chainKey)) {
+    return compiledChains.get(chainKey);
+  }
+  if (!jitAvailable) {
+    const interpretedFn = createInterpretedChain(hooks);
+    compiledChains.set(chainKey, interpretedFn);
+    return interpretedFn;
+  }
+  const validationSteps = hooks.map(
+    (h, i) => hasValidation(h) ? `if (!hooks[${i}].validate(quad)) return { valid: false, quad, failedHook: hooks[${i}].name };` : ""
+  ).filter(Boolean).join("\n    ");
+  const transformSteps = hooks.map((h, i) => hasTransformation(h) ? `quad = hooks[${i}].transform(quad);` : "").filter(Boolean).join("\n    ");
+  const fnBody = `
+    ${validationSteps}
+    ${transformSteps}
+    return { valid: true, quad };
+  `;
+  try {
+    const compiledFn = new Function("hooks", "quad", fnBody);
+    compiledChains.set(chainKey, compiledFn);
+    return compiledFn;
+  } catch {
+    jitAvailable = false;
+    const interpretedFn = createInterpretedChain(hooks);
+    compiledChains.set(chainKey, interpretedFn);
+    return interpretedFn;
+  }
+}
+function createInterpretedChain(hooks) {
+  const capturedHooks = hooks;
+  return function interpretedChain(_hooks, quad) {
+    let currentQuad = quad;
+    for (const hook of capturedHooks) {
+      if (hasValidation(hook)) {
+        if (!hook.validate(currentQuad)) {
+          return { valid: false, quad: currentQuad, failedHook: hook.name };
+        }
+      }
+      if (hasTransformation(hook)) {
+        currentQuad = hook.transform(currentQuad);
+      }
+    }
+    return { valid: true, quad: currentQuad };
+  };
+}
+function compileValidationOnlyChain(hooks) {
+  const chainKey = `validate:${getChainKey(hooks)}`;
+  if (compiledChains.has(chainKey)) {
+    return compiledChains.get(chainKey);
+  }
+  const validationHooks = hooks.filter(hasValidation);
+  if (!jitAvailable || validationHooks.length === 0) {
+    const fn = validationHooks.length === 0 ? () => true : (_hooks, quad) => validationHooks.every((h) => h.validate(quad));
+    compiledChains.set(chainKey, fn);
+    return fn;
+  }
+  const checks = validationHooks.map((_, i) => `hooks[${i}].validate(quad)`).join(" && ");
+  const fnBody = `return ${checks || "true"};`;
+  try {
+    const compiledFn = new Function("hooks", "quad", fnBody);
+    const wrapper = (_, quad) => compiledFn(validationHooks, quad);
+    compiledChains.set(chainKey, wrapper);
+    return wrapper;
+  } catch {
+    const fn = (_hooks, quad) => validationHooks.every((h) => h.validate(quad));
+    compiledChains.set(chainKey, fn);
+    return fn;
+  }
+}
+function clearCompiledChainCache() {
+  compiledChains.clear();
+}
+function getCompilerStats() {
+  return {
+    size: compiledChains.size,
+    jitAvailable
+  };
+}
+function isJitAvailable() {
+  return jitAvailable;
+}
+
+class QuadPool {
+  /**
+   * Create a new quad pool.
+   *
+   * @param {object} options - Pool options
+   * @param {number} options.size - Initial pool size (default: 1000)
+   * @param {boolean} options.autoGrow - Auto-grow pool when exhausted (default: true)
+   */
+  constructor(options = {}) {
+    this.size = options.size || 1e3;
+    this.autoGrow = options.autoGrow !== false;
+    this.pool = new Array(this.size);
+    this.index = 0;
+    this.acquired = 0;
+    this.highWaterMark = 0;
+    for (let i = 0; i < this.size; i++) {
+      this.pool[i] = this._createEmptyQuad();
+    }
+  }
+  /**
+   * Create an empty quad object for the pool.
+   *
+   * @private
+   * @returns {PooledQuad} - Empty quad object
+   */
+  _createEmptyQuad() {
+    return {
+      subject: null,
+      predicate: null,
+      object: null,
+      graph: null,
+      _pooled: true
+    };
+  }
+  /**
+   * Acquire a quad from the pool.
+   *
+   * @param {import('rdf-js').Term} subject - Subject term
+   * @param {import('rdf-js').Term} predicate - Predicate term
+   * @param {import('rdf-js').Term} object - Object term
+   * @param {import('rdf-js').Term} [graph] - Graph term (optional)
+   * @returns {PooledQuad} - Pooled quad with assigned values
+   *
+   * @example
+   * const quad = quadPool.acquire(subject, predicate, object, graph);
+   * // Use quad...
+   * quadPool.release(quad);
+   */
+  acquire(subject, predicate, object, graph = null) {
+    const quad = this.pool[this.index];
+    quad.subject = subject;
+    quad.predicate = predicate;
+    quad.object = object;
+    quad.graph = graph;
+    this.index = (this.index + 1) % this.size;
+    this.acquired++;
+    if (this.acquired > this.highWaterMark) {
+      this.highWaterMark = this.acquired;
+    }
+    if (this.autoGrow && this.acquired >= this.size) {
+      this._grow();
+    }
+    return quad;
+  }
+  /**
+   * Release a quad back to the pool.
+   *
+   * @param {PooledQuad} quad - Quad to release
+   */
+  release(quad) {
+    if (quad && quad._pooled) {
+      quad.subject = null;
+      quad.predicate = null;
+      quad.object = null;
+      quad.graph = null;
+      this.acquired = Math.max(0, this.acquired - 1);
+    }
+  }
+  /**
+   * Clone a pooled quad to a non-pooled object.
+   * Use this when you need to persist a quad beyond the current operation.
+   *
+   * @param {PooledQuad} quad - Quad to clone
+   * @param {Function} dataFactory - Data factory with quad() method
+   * @returns {import('rdf-js').Quad} - Non-pooled quad
+   */
+  clone(quad, dataFactory) {
+    return dataFactory.quad(quad.subject, quad.predicate, quad.object, quad.graph);
+  }
+  /**
+   * Grow the pool by doubling its size.
+   *
+   * @private
+   */
+  _grow() {
+    const newSize = this.size * 2;
+    const newPool = new Array(newSize);
+    for (let i = 0; i < this.size; i++) {
+      newPool[i] = this.pool[i];
+    }
+    for (let i = this.size; i < newSize; i++) {
+      newPool[i] = this._createEmptyQuad();
+    }
+    this.pool = newPool;
+    this.size = newSize;
+  }
+  /**
+   * Reset the pool (clear all references, reset index).
+   */
+  reset() {
+    for (let i = 0; i < this.size; i++) {
+      const quad = this.pool[i];
+      quad.subject = null;
+      quad.predicate = null;
+      quad.object = null;
+      quad.graph = null;
+    }
+    this.index = 0;
+    this.acquired = 0;
+  }
+  /**
+   * Get pool statistics.
+   *
+   * @returns {{size: number, acquired: number, available: number, highWaterMark: number}} - Pool stats
+   */
+  stats() {
+    return {
+      size: this.size,
+      acquired: this.acquired,
+      available: this.size - this.acquired,
+      highWaterMark: this.highWaterMark,
+      utilizationPercent: (this.acquired / this.size * 100).toFixed(1)
+    };
+  }
+}
+const quadPool = new QuadPool({ size: 1e3 });
+function createPooledTransform(transformFn, pool = quadPool) {
+  return function pooledTransform(quad) {
+    const result = transformFn(quad);
+    if (result !== quad) {
+      return pool.acquire(result.subject, result.predicate, result.object, result.graph);
+    }
+    return quad;
+  };
+}
+function isPooledQuad(quad) {
+  return quad && quad._pooled === true;
+}
+
+const HookRegistrySchema = z.object({
+  hooks: z.instanceof(Map),
+  triggerIndex: z.instanceof(Map)
+});
+function createHookRegistry() {
+  return {
+    hooks: /* @__PURE__ */ new Map(),
+    triggerIndex: /* @__PURE__ */ new Map()
+  };
+}
+function registerHook(registry, hook) {
+  const validatedRegistry = HookRegistrySchema.parse(registry);
+  const validatedHook = HookSchema.parse(hook);
+  if (validatedRegistry.hooks.has(validatedHook.name)) {
+    throw new Error(`Hook already registered: ${validatedHook.name}`);
+  }
+  validatedRegistry.hooks.set(validatedHook.name, validatedHook);
+  if (!validatedRegistry.triggerIndex.has(validatedHook.trigger)) {
+    validatedRegistry.triggerIndex.set(validatedHook.trigger, /* @__PURE__ */ new Set());
+  }
+  validatedRegistry.triggerIndex.get(validatedHook.trigger).add(validatedHook.name);
+}
+function unregisterHook(registry, name) {
+  const validatedRegistry = HookRegistrySchema.parse(registry);
+  const hook = validatedRegistry.hooks.get(name);
+  if (!hook) {
+    return false;
+  }
+  validatedRegistry.hooks.delete(name);
+  const triggerSet = validatedRegistry.triggerIndex.get(hook.trigger);
+  if (triggerSet) {
+    triggerSet.delete(name);
+    if (triggerSet.size === 0) {
+      validatedRegistry.triggerIndex.delete(hook.trigger);
+    }
+  }
+  return true;
+}
+function getHook(registry, name) {
+  const validatedRegistry = HookRegistrySchema.parse(registry);
+  return validatedRegistry.hooks.get(name);
+}
+function listHooks(registry) {
+  const validatedRegistry = HookRegistrySchema.parse(registry);
+  return Array.from(validatedRegistry.hooks.values());
+}
+function getHooksByTrigger(registry, trigger) {
+  const validatedRegistry = HookRegistrySchema.parse(registry);
+  const hookNames = validatedRegistry.triggerIndex.get(trigger);
+  if (!hookNames) {
+    return [];
+  }
+  const hooks = [];
+  for (const name of hookNames) {
+    const hook = validatedRegistry.hooks.get(name);
+    if (hook) {
+      hooks.push(hook);
+    }
+  }
+  return hooks;
+}
+function hasHook(registry, name) {
+  const validatedRegistry = HookRegistrySchema.parse(registry);
+  return validatedRegistry.hooks.has(name);
+}
+function clearHooks(registry) {
+  const validatedRegistry = HookRegistrySchema.parse(registry);
+  validatedRegistry.hooks.clear();
+  validatedRegistry.triggerIndex.clear();
+}
+function getRegistryStats(registry) {
+  const validatedRegistry = HookRegistrySchema.parse(registry);
+  const byTrigger = {};
+  for (const [trigger, names] of validatedRegistry.triggerIndex) {
+    byTrigger[trigger] = names.size;
+  }
+  return {
+    totalHooks: validatedRegistry.hooks.size,
+    byTrigger
+  };
+}
+
+const validateSubjectIRI = defineHook({
+  name: "validate-subject-iri",
+  trigger: "before-add",
+  validate: (quad) => {
+    return quad.subject.termType === "NamedNode";
+  },
+  metadata: {
+    description: "Validates that quad subject is a Named Node (IRI)"
+  }
+});
+const validatePredicateIRI = defineHook({
+  name: "validate-predicate-iri",
+  trigger: "before-add",
+  validate: (quad) => {
+    return quad.predicate.termType === "NamedNode";
+  },
+  metadata: {
+    description: "Validates that quad predicate is a Named Node (IRI)"
+  }
+});
+const validateObjectLiteral = defineHook({
+  name: "validate-object-literal",
+  trigger: "before-add",
+  validate: (quad) => {
+    return quad.object.termType === "Literal";
+  },
+  metadata: {
+    description: "Validates that quad object is a Literal"
+  }
+});
+const validateIRIFormat = defineHook({
+  name: "validate-iri-format",
+  trigger: "before-add",
+  validate: (quad) => {
+    const validateIRI = (term) => {
+      if (term.termType !== "NamedNode") {
+        return true;
+      }
+      try {
+        new URL(term.value);
+        return true;
+      } catch {
+        return false;
+      }
+    };
+    return validateIRI(quad.subject) && validateIRI(quad.predicate) && validateIRI(quad.object);
+  },
+  metadata: {
+    description: "Validates that IRI values are well-formed URLs"
+  }
+});
+const validateLanguageTag = defineHook({
+  name: "validate-language-tag",
+  trigger: "before-add",
+  validate: (quad) => {
+    if (quad.object.termType !== "Literal") {
+      return true;
+    }
+    return quad.object.language !== void 0 && quad.object.language !== "";
+  },
+  metadata: {
+    description: "Validates that literal objects have language tags"
+  }
+});
+const rejectBlankNodes = defineHook({
+  name: "reject-blank-nodes",
+  trigger: "before-add",
+  validate: (quad) => {
+    return quad.subject.termType !== "BlankNode" && quad.object.termType !== "BlankNode";
+  },
+  metadata: {
+    description: "Rejects quads containing blank nodes"
+  }
+});
+const normalizeNamespace = defineHook({
+  name: "normalize-namespace",
+  trigger: "before-add",
+  transform: (quad) => {
+    return quad;
+  },
+  metadata: {
+    description: "Normalizes namespace prefixes to full IRIs"
+  }
+});
+const normalizeLanguageTag = defineHook({
+  name: "normalize-language-tag",
+  trigger: "before-add",
+  transform: (quad) => {
+    if (quad.object.termType !== "Literal" || !quad.object.language) {
+      return quad;
+    }
+    return dataFactory.quad(
+      quad.subject,
+      quad.predicate,
+      dataFactory.literal(quad.object.value, quad.object.language.toLowerCase()),
+      quad.graph
+    );
+  },
+  metadata: {
+    description: "Normalizes language tags to lowercase"
+  }
+});
+const trimLiterals = defineHook({
+  name: "trim-literals",
+  trigger: "before-add",
+  transform: (quad) => {
+    if (quad.object.termType !== "Literal") {
+      return quad;
+    }
+    return dataFactory.quad(
+      quad.subject,
+      quad.predicate,
+      dataFactory.literal(quad.object.value.trim(), quad.object.language || quad.object.datatype),
+      quad.graph
+    );
+  },
+  metadata: {
+    description: "Trims whitespace from literal values"
+  }
+});
+const standardValidation = defineHook({
+  name: "standard-validation",
+  trigger: "before-add",
+  validate: (quad) => {
+    return quad.predicate.termType === "NamedNode" && (quad.subject.termType === "NamedNode" || quad.subject.termType === "BlankNode");
+  },
+  metadata: {
+    description: "Standard RDF validation rules"
+  }
+});
+const normalizeLanguageTagPooled = defineHook({
+  name: "normalize-language-tag-pooled",
+  trigger: "before-add",
+  transform: (quad) => {
+    const isLiteral = quad.object.termType === "Literal";
+    const hasLanguage = isLiteral && quad.object.language;
+    if (!hasLanguage) return quad;
+    return quadPool.acquire(
+      quad.subject,
+      quad.predicate,
+      dataFactory.literal(quad.object.value, quad.object.language.toLowerCase()),
+      quad.graph
+    );
+  },
+  metadata: {
+    description: "Zero-allocation language tag normalization using quad pool",
+    pooled: true
+  }
+});
+const trimLiteralsPooled = defineHook({
+  name: "trim-literals-pooled",
+  trigger: "before-add",
+  transform: (quad) => {
+    if (quad.object.termType !== "Literal") return quad;
+    const trimmed = quad.object.value.trim();
+    if (trimmed === quad.object.value) return quad;
+    return quadPool.acquire(
+      quad.subject,
+      quad.predicate,
+      dataFactory.literal(trimmed, quad.object.language || quad.object.datatype),
+      quad.graph
+    );
+  },
+  metadata: {
+    description: "Zero-allocation literal trimming using quad pool",
+    pooled: true
+  }
+});
+const builtinHooks = {
+  // Validation
+  validateSubjectIRI,
+  validatePredicateIRI,
+  validateObjectLiteral,
+  validateIRIFormat,
+  validateLanguageTag,
+  rejectBlankNodes,
+  // Transformation
+  normalizeNamespace,
+  normalizeLanguageTag,
+  trimLiterals,
+  // Pooled variants (zero-allocation)
+  normalizeLanguageTagPooled,
+  trimLiteralsPooled,
+  // Composite
+  standardValidation
+};
+
+class KnowledgeHookManager {
+  /**
+   * @private
+   * @type {import('./hook-management.mjs').HookRegistry}
+   */
+  #registry;
+  /**
+   * POKA-YOKE: Recursive execution guard (RPN 128 → 0)
+   * @private
+   * @type {number}
+   */
+  #executionDepth = 0;
+  /**
+   * Maximum allowed execution depth
+   * @private
+   * @type {number}
+   */
+  #maxExecutionDepth = 3;
+  /**
+   * Create a new KnowledgeHookManager
+   *
+   * @param {Object} [options] - Configuration options
+   * @param {boolean} [options.includeBuiltins=false] - Include built-in hooks
+   * @param {number} [options.maxExecutionDepth=3] - Maximum recursion depth (1-10)
+   */
+  constructor(options = {}) {
+    this.#registry = createHookRegistry();
+    if (options.maxExecutionDepth !== void 0) {
+      if (options.maxExecutionDepth < 1 || options.maxExecutionDepth > 10) {
+        throw new Error(
+          `[POKA-YOKE] maxExecutionDepth must be between 1 and 10, got ${options.maxExecutionDepth}`
+        );
+      }
+      this.#maxExecutionDepth = options.maxExecutionDepth;
+    }
+    if (options.includeBuiltins) {
+      for (const hook of Object.values(builtinHooks)) {
+        registerHook(this.#registry, hook);
+      }
+    }
+  }
+  /**
+   * Get current execution depth
+   * @returns {number}
+   */
+  getExecutionDepth() {
+    return this.#executionDepth;
+  }
+  /**
+   * Check if currently executing hooks
+   * @returns {boolean}
+   */
+  isExecuting() {
+    return this.#executionDepth > 0;
+  }
+  /**
+   * Define and register a hook
+   *
+   * @param {import('./define-hook.mjs').HookConfig} hookDef - Hook definition
+   * @returns {import('./define-hook.mjs').Hook} The defined hook
+   */
+  define(hookDef) {
+    const hook = defineHook(hookDef);
+    registerHook(this.#registry, hook);
+    return hook;
+  }
+  /**
+   * Register a hook
+   *
+   * @param {import('./define-hook.mjs').Hook} hook - Hook to register
+   * @returns {void}
+   */
+  registerHook(hook) {
+    registerHook(this.#registry, hook);
+  }
+  /**
+   * Unregister a hook
+   *
+   * @param {string} hookId - ID of hook to unregister
+   * @returns {boolean} True if hook was removed
+   */
+  unregisterHook(hookId) {
+    return unregisterHook(this.#registry, hookId);
+  }
+  /**
+   * Get a hook by ID
+   *
+   * @param {string} hookId - Hook ID
+   * @returns {import('./define-hook.mjs').Hook | undefined}
+   */
+  getHook(hookId) {
+    return getHook(this.#registry, hookId);
+  }
+  /**
+   * List all hooks
+   *
+   * @param {Object} [options] - Filter options
+   * @param {string} [options.trigger] - Filter by trigger
+   * @param {boolean} [options.enabled] - Filter by enabled status
+   * @returns {import('./define-hook.mjs').Hook[]}
+   */
+  listHooks(options) {
+    return listHooks(this.#registry);
+  }
+  /**
+   * Get hooks by trigger
+   *
+   * @param {string} trigger - Trigger to filter by
+   * @returns {import('./define-hook.mjs').Hook[]}
+   */
+  getHooksByTrigger(trigger) {
+    return getHooksByTrigger(this.#registry, trigger);
+  }
+  /**
+   * Check if hook exists
+   *
+   * @param {string} hookId - Hook ID
+   * @returns {boolean}
+   */
+  hasHook(hookId) {
+    return hasHook(this.#registry, hookId);
+  }
+  /**
+   * Clear all hooks
+   *
+   * @returns {void}
+   */
+  clearHooks() {
+    clearHooks(this.#registry);
+  }
+  /**
+   * Get registry statistics
+   *
+   * @returns {{ total: number, enabled: number, disabled: number, byTrigger: Record<string, number> }}
+   */
+  getStats() {
+    return getRegistryStats(this.#registry);
+  }
+  /**
+   * Execute a specific hook
+   *
+   * @param {string} hookId - Hook ID
+   * @param {*} data - Data to process
+   * @param {*} context - Execution context
+   * @returns {Promise<import('./hook-executor.mjs').HookResult>}
+   */
+  async executeHook(hookId, data, context) {
+    const hook = this.getHook(hookId);
+    if (!hook) {
+      throw new Error(`Hook not found: ${hookId}`);
+    }
+    return executeHook(hook, data, context);
+  }
+  /**
+   * Execute hooks in chain
+   *
+   * @param {import('./define-hook.mjs').Hook[]} hooks - Hooks to execute
+   * @param {*} data - Initial data
+   * @param {*} context - Execution context
+   * @returns {Promise<import('./hook-executor.mjs').ChainResult>}
+   */
+  async executeChain(hooks, data, context) {
+    return executeHookChain(hooks, data);
+  }
+  /**
+   * Execute hooks by trigger
+   *
+   * @param {string} trigger - Trigger to execute
+   * @param {*} data - Data to process
+   * @param {*} context - Execution context
+   * @returns {Promise<import('./hook-executor.mjs').ChainResult>}
+   */
+  async executeByTrigger(trigger, data, context) {
+    if (this.#executionDepth >= this.#maxExecutionDepth) {
+      const error = new Error(
+        `[POKA-YOKE] Recursive hook execution detected (depth: ${this.#executionDepth}, max: ${this.#maxExecutionDepth}). Trigger: ${trigger}`
+      );
+      error.code = "RECURSIVE_HOOK_EXECUTION";
+      throw error;
+    }
+    this.#executionDepth++;
+    try {
+      const hooks = this.listHooks();
+      return executeHooksByTrigger(hooks, trigger, data, context);
+    } finally {
+      this.#executionDepth--;
+    }
+  }
+  /**
+   * Check if data would pass hooks
+   *
+   * @param {string} trigger - Trigger to check
+   * @param {*} data - Data to validate
+   * @param {*} context - Execution context
+   * @returns {Promise<boolean>}
+   */
+  async wouldPass(trigger, data, context) {
+    const hooks = this.getHooksByTrigger(trigger);
+    return wouldPassHooks(hooks, data);
+  }
+  /**
+   * Get built-in hooks
+   *
+   * @returns {import('./define-hook.mjs').Hook[]}
+   */
+  static getBuiltinHooks() {
+    return Object.values(builtinHooks);
+  }
+}
+
+const ScheduleConfigSchema = z.object({
+  id: z.string().min(1),
+  hookId: z.string().min(1),
+  type: z.enum(["cron", "interval", "idle", "startup"]),
+  expression: z.string().optional(),
+  // Cron expression
+  // POKA-YOKE: Interval bounds validation (RPN 168 → 0)
+  // Min 10ms prevents CPU thrashing, max 24h prevents integer overflow
+  intervalMs: z.number().positive().min(10, "Interval must be at least 10ms to prevent CPU thrashing").max(864e5, "Interval cannot exceed 24 hours (86400000ms)").optional(),
+  idleTimeoutMs: z.number().positive().min(100, "Idle timeout must be at least 100ms").max(36e5, "Idle timeout cannot exceed 1 hour").optional(),
+  enabled: z.boolean().default(true),
+  maxRuns: z.number().positive().optional(),
+  // Max executions
+  metadata: z.record(z.any()).optional()
+});
+class HookScheduler {
+  /**
+   * Create a new hook scheduler
+   *
+   * @param {object} options - Scheduler options
+   * @param {Function} options.executeHook - Hook execution function
+   * @param {number} options.tickInterval - Scheduler tick interval (default: 1000ms)
+   */
+  constructor(options = {}) {
+    this.schedules = /* @__PURE__ */ new Map();
+    this.executeHook = options.executeHook || (async () => {
+    });
+    this.tickInterval = options.tickInterval || 1e3;
+    this.ticker = null;
+    this.running = false;
+    this.lastTick = null;
+    this.idleThreshold = options.idleThreshold || 5e3;
+    this.idleStart = Date.now();
+    this.startupQueue = [];
+  }
+  /**
+   * Register a scheduled hook
+   *
+   * @param {import('./define-hook.mjs').Hook} hook - Hook to schedule
+   * @param {object} config - Schedule configuration
+   * @returns {ScheduledHook} - Registered scheduled hook
+   */
+  register(hook, config) {
+    const validConfig = ScheduleConfigSchema.parse(config);
+    const scheduled = {
+      id: validConfig.id,
+      hook,
+      type: validConfig.type,
+      expression: validConfig.expression,
+      interval: validConfig.intervalMs,
+      idleTimeout: validConfig.idleTimeoutMs,
+      enabled: validConfig.enabled,
+      lastRun: null,
+      nextRun: this._calculateNextRun(validConfig),
+      runCount: 0,
+      maxRuns: validConfig.maxRuns,
+      metadata: validConfig.metadata || {}
+    };
+    this.schedules.set(validConfig.id, scheduled);
+    if (validConfig.type === "startup") {
+      this.startupQueue.push(scheduled);
+    }
+    return scheduled;
+  }
+  /**
+   * Unregister a scheduled hook
+   *
+   * @param {string} id - Schedule ID to remove
+   */
+  unregister(id) {
+    this.schedules.delete(id);
+  }
+  /**
+   * Start the scheduler
+   */
+  start() {
+    if (this.running) return;
+    this.running = true;
+    this.lastTick = /* @__PURE__ */ new Date();
+    this._executeStartupHooks();
+    this.ticker = setInterval(() => this._tick(), this.tickInterval);
+  }
+  /**
+   * Stop the scheduler
+   */
+  stop() {
+    if (!this.running) return;
+    this.running = false;
+    if (this.ticker) {
+      clearInterval(this.ticker);
+      this.ticker = null;
+    }
+  }
+  /**
+   * Notify scheduler of activity (resets idle timer)
+   */
+  notifyActivity() {
+    this.idleStart = Date.now();
+  }
+  /**
+   * Get scheduler statistics
+   *
+   * @returns {object} - Scheduler stats
+   */
+  getStats() {
+    const schedules = Array.from(this.schedules.values());
+    return {
+      totalSchedules: schedules.length,
+      enabledSchedules: schedules.filter((s) => s.enabled).length,
+      totalRuns: schedules.reduce((sum, s) => sum + s.runCount, 0),
+      byType: {
+        cron: schedules.filter((s) => s.type === "cron").length,
+        interval: schedules.filter((s) => s.type === "interval").length,
+        idle: schedules.filter((s) => s.type === "idle").length,
+        startup: schedules.filter((s) => s.type === "startup").length
+      },
+      running: this.running,
+      idleSince: this.idleStart
+    };
+  }
+  /**
+   * Execute startup hooks
+   * @private
+   */
+  async _executeStartupHooks() {
+    for (const scheduled of this.startupQueue) {
+      if (scheduled.enabled && scheduled.runCount === 0) {
+        await this._executeScheduled(scheduled);
+      }
+    }
+    this.startupQueue = [];
+  }
+  /**
+   * Scheduler tick - check and execute due hooks
+   * @private
+   */
+  async _tick() {
+    const now = /* @__PURE__ */ new Date();
+    const isIdle = Date.now() - this.idleStart > this.idleThreshold;
+    for (const scheduled of this.schedules.values()) {
+      if (!scheduled.enabled) continue;
+      if (scheduled.maxRuns && scheduled.runCount >= scheduled.maxRuns) continue;
+      let shouldRun = false;
+      switch (scheduled.type) {
+        case "interval":
+          shouldRun = scheduled.nextRun && now >= scheduled.nextRun;
+          break;
+        case "idle":
+          shouldRun = isIdle && (!scheduled.lastRun || Date.now() - scheduled.lastRun.getTime() > (scheduled.idleTimeout || this.idleThreshold));
+          break;
+        case "cron":
+          shouldRun = scheduled.nextRun && now >= scheduled.nextRun;
+          break;
+      }
+      if (shouldRun) {
+        await this._executeScheduled(scheduled);
+      }
+    }
+    this.lastTick = now;
+  }
+  /**
+   * Execute a scheduled hook
+   * POKA-YOKE: Circuit breaker disables after 3 consecutive failures (RPN 432 → 43)
+   * @private
+   */
+  async _executeScheduled(scheduled) {
+    try {
+      scheduled.lastRun = /* @__PURE__ */ new Date();
+      scheduled.runCount++;
+      scheduled.nextRun = this._calculateNextRun(scheduled);
+      await this.executeHook(scheduled.hook, {
+        scheduledId: scheduled.id,
+        runCount: scheduled.runCount,
+        scheduledTime: scheduled.lastRun
+      });
+      scheduled.errorCount = 0;
+      scheduled.lastError = null;
+    } catch (error) {
+      scheduled.lastError = error instanceof Error ? error : new Error(String(error));
+      scheduled.errorCount = (scheduled.errorCount || 0) + 1;
+      if (this.onError) {
+        this.onError({
+          scheduledId: scheduled.id,
+          hookName: scheduled.hook?.name || "unknown",
+          error: scheduled.lastError,
+          errorCount: scheduled.errorCount,
+          timestamp: /* @__PURE__ */ new Date()
+        });
+      }
+      console.error(
+        `[POKA-YOKE] Scheduled hook "${scheduled.id}" failed (attempt ${scheduled.errorCount}/3):`,
+        scheduled.lastError.message
+      );
+      if (scheduled.errorCount >= 3) {
+        scheduled.enabled = false;
+        console.warn(
+          `[POKA-YOKE] Scheduled hook "${scheduled.id}" disabled after 3 consecutive failures. Last error: ${scheduled.lastError.message}. Re-enable with scheduler.enable("${scheduled.id}") after fixing the issue.`
+        );
+        if (this.onCircuitOpen) {
+          this.onCircuitOpen({
+            scheduledId: scheduled.id,
+            hookName: scheduled.hook?.name || "unknown",
+            lastError: scheduled.lastError,
+            totalErrors: scheduled.errorCount,
+            timestamp: /* @__PURE__ */ new Date()
+          });
+        }
+      }
+    }
+  }
+  /**
+   * Re-enable a disabled scheduled hook
+   *
+   * @param {string} id - Schedule ID to enable
+   * @returns {boolean} - True if enabled, false if not found
+   */
+  enable(id) {
+    const scheduled = this.schedules.get(id);
+    if (!scheduled) return false;
+    scheduled.enabled = true;
+    scheduled.errorCount = 0;
+    scheduled.lastError = null;
+    return true;
+  }
+  /**
+   * Calculate next run time for a schedule
+   * @private
+   */
+  _calculateNextRun(config) {
+    const now = /* @__PURE__ */ new Date();
+    switch (config.type) {
+      case "interval":
+        return new Date(now.getTime() + (config.intervalMs || config.interval || 6e4));
+      case "cron":
+        return this._parseCronExpression(config.expression);
+      case "idle":
+      case "startup":
+        return null;
+      // Event-driven, not time-driven
+      default:
+        return null;
+    }
+  }
+  /**
+   * Simple cron expression parser
+   * POKA-YOKE: Strict validation instead of silent fallback (RPN 315 → 0)
+   * Supports intervals in the format star-slash-n (e.g., star-slash-5 = every 5 minutes)
+   * @private
+   */
+  _parseCronExpression(expression) {
+    if (!expression) {
+      throw new Error(
+        'Cron expression is required for type "cron". Use "*/n" format for intervals (e.g., "*/5" for every 5 minutes).'
+      );
+    }
+    const intervalMatch = expression.match(/^\*\/(\d+)$/);
+    if (intervalMatch) {
+      const minutes = parseInt(intervalMatch[1], 10);
+      if (minutes < 1 || minutes > 1440) {
+        throw new Error(
+          `Invalid cron interval: */[${minutes}]. Value must be between 1 and 1440 minutes (24 hours). Example: "*/5" for every 5 minutes.`
+        );
+      }
+      return new Date(Date.now() + minutes * 60 * 1e3);
+    }
+    throw new Error(
+      `Invalid cron expression: "${expression}". Supported format: "*/n" where n is minutes (1-1440). Example: "*/5" for every 5 minutes, "*/60" for every hour.`
+    );
+  }
+}
+function createHookScheduler(options = {}) {
+  return new HookScheduler(options);
+}
+
+const QualityGateSchema = z.object({
+  name: z.string().min(1, "Gate name is required"),
+  metric: z.string().min(1, "Metric name is required"),
+  operator: z.enum(["gt", "gte", "lt", "lte", "eq", "neq", "between"]),
+  threshold: z.number().or(z.array(z.number())),
+  severity: z.enum(["critical", "major", "minor"]).default("major"),
+  action: z.enum(["block", "warn", "log"]).default("block")
+}).refine(
+  (data) => {
+    if (data.operator === "between") {
+      return Array.isArray(data.threshold) && data.threshold.length === 2;
+    }
+    return typeof data.threshold === "number";
+  },
+  {
+    message: "Operator 'between' requires threshold as [min, max] array; other operators require a single number. Example: { operator: 'between', threshold: [10, 90] } or { operator: 'gt', threshold: 50 }"
+  }
+).refine(
+  (data) => {
+    if (data.operator === "between" && Array.isArray(data.threshold)) {
+      return data.threshold[0] <= data.threshold[1];
+    }
+    return true;
+  },
+  {
+    message: "For 'between' operator, threshold[0] (min) must be <= threshold[1] (max)"
+  }
+);
+const SPCDataPointSchema = z.object({
+  timestamp: z.date().or(z.string().transform((s) => new Date(s))),
+  value: z.number(),
+  subgroup: z.string().optional()
+});
+class QualityMetricsCollector {
+  /**
+   * Create a new quality metrics collector
+   *
+   * @param {object} options - Collector options
+   */
+  constructor(options = {}) {
+    this.dataPoints = /* @__PURE__ */ new Map();
+    this.metrics = /* @__PURE__ */ new Map();
+    this.defects = [];
+    this.maxDataPoints = options.maxDataPoints || 1e3;
+    this.qualityGates = /* @__PURE__ */ new Map();
+    this.auditLog = [];
+    this.maxAuditLogSize = options.maxAuditLogSize || 1e4;
+    this.defectCount = 0;
+    this.totalCount = 0;
+  }
+  /**
+   * Record a data point for a metric
+   *
+   * @param {string} metricName - Metric name
+   * @param {number} value - Measured value
+   * @param {object} context - Additional context
+   */
+  record(metricName, value, context = {}) {
+    if (!this.dataPoints.has(metricName)) {
+      this.dataPoints.set(metricName, []);
+    }
+    const points = this.dataPoints.get(metricName);
+    points.push(value);
+    if (points.length > this.maxDataPoints) {
+      points.shift();
+    }
+    this.totalCount++;
+    this._checkControlLimits(metricName, value, context);
+  }
+  /**
+   * Record a defect
+   *
+   * @param {object} defect - Defect information
+   */
+  recordDefect(defect) {
+    const record = {
+      id: `DEF-${Date.now()}-${this.defects.length}`,
+      timestamp: /* @__PURE__ */ new Date(),
+      ...defect
+    };
+    this.defects.push(record);
+    this.defectCount++;
+    this._auditLog("defect-recorded", record);
+  }
+  /**
+   * Register a quality gate
+   *
+   * @param {object} gate - Quality gate configuration
+   */
+  registerQualityGate(gate) {
+    const validated = QualityGateSchema.parse(gate);
+    this.qualityGates.set(validated.name, validated);
+  }
+  /**
+   * Check a value against quality gates
+   *
+   * @param {string} metricName - Metric to check
+   * @param {number} value - Value to check
+   * @returns {{passed: boolean, violations: object[]}} - Check result
+   */
+  checkQualityGates(metricName, value) {
+    const violations = [];
+    for (const gate of this.qualityGates.values()) {
+      if (gate.metric !== metricName) continue;
+      const passed = this._evaluateGate(gate, value);
+      if (!passed) {
+        violations.push({
+          gate: gate.name,
+          metric: metricName,
+          value,
+          threshold: gate.threshold,
+          operator: gate.operator,
+          severity: gate.severity,
+          action: gate.action
+        });
+      }
+    }
+    return {
+      passed: violations.length === 0,
+      violations
+    };
+  }
+  /**
+   * Calculate Statistical Process Control metrics
+   *
+   * @param {string} metricName - Metric name
+   * @returns {object} - SPC metrics (mean, stdDev, UCL, LCL, Cp, Cpk)
+   */
+  calculateSPC(metricName) {
+    const points = this.dataPoints.get(metricName) || [];
+    if (points.length < 2) {
+      return { error: "Insufficient data points" };
+    }
+    const mean = points.reduce((sum, v) => sum + v, 0) / points.length;
+    const variance = points.reduce((sum, v) => sum + Math.pow(v - mean, 2), 0) / (points.length - 1);
+    const stdDev = Math.sqrt(variance);
+    const ucl = mean + 3 * stdDev;
+    const lcl = mean - 3 * stdDev;
+    const metric = this.metrics.get(metricName);
+    let cp = null;
+    let cpk = null;
+    if (metric && metric.ucl !== void 0 && metric.lcl !== void 0) {
+      const usl = metric.ucl;
+      const lsl = metric.lcl;
+      cp = (usl - lsl) / (6 * stdDev);
+      cpk = Math.min((usl - mean) / (3 * stdDev), (mean - lsl) / (3 * stdDev));
+    }
+    return {
+      mean,
+      stdDev,
+      ucl,
+      lcl,
+      cp,
+      cpk,
+      n: points.length,
+      min: Math.min(...points),
+      max: Math.max(...points)
+    };
+  }
+  /**
+   * Detect statistical outliers (defects)
+   *
+   * @param {string} metricName - Metric name
+   * @param {number} sigmaLevel - Sigma level for detection (default: 3)
+   * @returns {number[]} - Indices of outlier data points
+   */
+  detectOutliers(metricName, sigmaLevel = 3) {
+    const spc = this.calculateSPC(metricName);
+    if (spc.error) return [];
+    const points = this.dataPoints.get(metricName) || [];
+    const threshold = sigmaLevel * spc.stdDev;
+    return points.map((v, i) => ({ value: v, index: i })).filter(({ value }) => Math.abs(value - spc.mean) > threshold).map(({ index }) => index);
+  }
+  /**
+   * Calculate Defects Per Million Opportunities (DPMO)
+   *
+   * @returns {number} - DPMO value
+   */
+  calculateDPMO() {
+    if (this.totalCount === 0) return 0;
+    return this.defectCount / this.totalCount * 1e6;
+  }
+  /**
+   * Calculate Sigma Level
+   *
+   * @returns {number} - Sigma level (higher is better)
+   */
+  calculateSigmaLevel() {
+    const dpmo = this.calculateDPMO();
+    if (dpmo === 0) return 6;
+    if (dpmo <= 3.4) return 6;
+    if (dpmo <= 233) return 5;
+    if (dpmo <= 6210) return 4;
+    if (dpmo <= 66807) return 3;
+    if (dpmo <= 308538) return 2;
+    if (dpmo <= 691462) return 1;
+    return 0;
+  }
+  /**
+   * Generate 5 Whys root cause analysis template
+   *
+   * @param {DefectRecord} defect - Defect to analyze
+   * @returns {object} - 5 Whys template
+   */
+  generateRootCauseTemplate(defect) {
+    return {
+      defectId: defect.id,
+      problem: defect.type,
+      why1: { question: "Why did this happen?", answer: null },
+      why2: { question: "Why did that cause this?", answer: null },
+      why3: { question: "Why was that the case?", answer: null },
+      why4: { question: "Why did that occur?", answer: null },
+      why5: { question: "What is the root cause?", answer: null },
+      rootCause: null,
+      preventiveAction: null,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Register a Kaizen improvement event
+   *
+   * @param {object} event - Kaizen event details
+   */
+  registerKaizenEvent(event) {
+    const record = {
+      id: `KAIZEN-${Date.now()}`,
+      type: "kaizen-event",
+      timestamp: /* @__PURE__ */ new Date(),
+      status: "open",
+      ...event
+    };
+    this._auditLog("kaizen-registered", record);
+    return record;
+  }
+  /**
+   * Get quality summary report
+   *
+   * @returns {object} - Quality summary
+   */
+  getSummary() {
+    return {
+      totalMeasurements: this.totalCount,
+      totalDefects: this.defectCount,
+      dpmo: this.calculateDPMO(),
+      sigmaLevel: this.calculateSigmaLevel(),
+      metricsTracked: this.metrics.size,
+      dataPointsStored: Array.from(this.dataPoints.values()).reduce(
+        (sum, arr) => sum + arr.length,
+        0
+      ),
+      qualityGatesRegistered: this.qualityGates.size,
+      auditLogEntries: this.auditLog.length,
+      recentDefects: this.defects.slice(-10)
+    };
+  }
+  /**
+   * Export audit trail
+   *
+   * @param {object} options - Export options
+   * @returns {Array} - Audit trail entries
+   */
+  exportAuditTrail(options = {}) {
+    let entries = [...this.auditLog];
+    if (options.startTime) {
+      entries = entries.filter((e) => e.timestamp >= options.startTime);
+    }
+    if (options.endTime) {
+      entries = entries.filter((e) => e.timestamp <= options.endTime);
+    }
+    if (options.type) {
+      entries = entries.filter((e) => e.type === options.type);
+    }
+    return entries;
+  }
+  /**
+   * Check control limits and record violations
+   * @private
+   */
+  _checkControlLimits(metricName, value, context) {
+    const spc = this.calculateSPC(metricName);
+    if (spc.error) return;
+    if (value > spc.ucl || value < spc.lcl) {
+      this.recordDefect({
+        type: "control-limit-violation",
+        source: metricName,
+        severity: "major",
+        context: {
+          value,
+          ucl: spc.ucl,
+          lcl: spc.lcl,
+          mean: spc.mean,
+          ...context
+        }
+      });
+    }
+  }
+  /**
+   * Evaluate a quality gate
+   * @private
+   */
+  _evaluateGate(gate, value) {
+    switch (gate.operator) {
+      case "gt":
+        return value > gate.threshold;
+      case "gte":
+        return value >= gate.threshold;
+      case "lt":
+        return value < gate.threshold;
+      case "lte":
+        return value <= gate.threshold;
+      case "eq":
+        return value === gate.threshold;
+      case "neq":
+        return value !== gate.threshold;
+      case "between":
+        return Array.isArray(gate.threshold) && value >= gate.threshold[0] && value <= gate.threshold[1];
+      default:
+        return true;
+    }
+  }
+  /**
+   * Add entry to audit log
+   * POKA-YOKE: Includes size limit to prevent memory exhaustion (RPN 448 → 45)
+   * @private
+   */
+  _auditLog(type, data) {
+    if (this.auditLog.length >= this.maxAuditLogSize) {
+      const removeCount = Math.max(1, Math.floor(this.maxAuditLogSize * 0.1));
+      this.auditLog.splice(0, removeCount);
+      if (!this._auditEvictionWarned) {
+        console.warn(
+          `[POKA-YOKE] Audit log reached max size (${this.maxAuditLogSize}). Oldest entries will be evicted. Increase maxAuditLogSize if needed.`
+        );
+        this._auditEvictionWarned = true;
+      }
+    }
+    this.auditLog.push({
+      type,
+      timestamp: /* @__PURE__ */ new Date(),
+      data
+    });
+  }
+}
+function createQualityHooks(collector) {
+  return {
+    /**
+     * Create a quality gate validation hook
+     */
+    createQualityGateHook: (gateName, metricExtractor) => ({
+      name: `quality-gate-${gateName}`,
+      trigger: "quality-gate",
+      validate: (data) => {
+        const value = metricExtractor(data);
+        const result = collector.checkQualityGates(gateName, value);
+        if (!result.passed) {
+          const criticalViolations = result.violations.filter((v) => v.action === "block");
+          return criticalViolations.length === 0;
+        }
+        return true;
+      },
+      metadata: { gateName }
+    }),
+    /**
+     * Create a defect detection hook
+     */
+    createDefectDetectionHook: (metricName, extractor) => ({
+      name: `defect-detection-${metricName}`,
+      trigger: "defect-detection",
+      validate: (data) => {
+        const value = extractor(data);
+        collector.record(metricName, value);
+        const outliers = collector.detectOutliers(metricName);
+        return outliers.length === 0;
+      },
+      metadata: { metricName }
+    }),
+    /**
+     * Create an audit trail hook
+     */
+    createAuditTrailHook: (operationType) => ({
+      name: `audit-trail-${operationType}`,
+      trigger: "audit-trail",
+      transform: (data) => {
+        collector._auditLog(operationType, { data, timestamp: /* @__PURE__ */ new Date() });
+        return data;
+      },
+      metadata: { operationType }
+    })
+  };
+}
+
+export { ChainResultSchema, HookConfigSchema, HookRegistrySchema, HookResultSchema, HookScheduler, HookSchema, HookTriggerSchema, KnowledgeHookManager, QuadPool, QualityGateSchema, QualityMetricsCollector, SPCDataPointSchema, ScheduleConfigSchema, builtinHooks, clearCompiledChainCache, clearHookCaches, clearHooks, compileHookChain, compileValidationOnlyChain, createHookRegistry, createHookScheduler, createPooledTransform, createQualityHooks, defineHook, executeBatch, executeHook, executeHookChain, executeHooksByTrigger, getChainKey, getCompilerStats, getHook, getHookMetadata, getHooksByTrigger, getRegistryStats, hasHook, hasTransformation$1 as hasTransformation, hasValidation$1 as hasValidation, isJitAvailable, isPooledQuad, isValidHook, listHooks, normalizeLanguageTag, normalizeLanguageTagPooled, normalizeNamespace, prewarmHookCache, quadPool, registerHook, rejectBlankNodes, standardValidation, transformBatch, trimLiterals, trimLiteralsPooled, unregisterHook, validateBatch, validateIRIFormat, validateLanguageTag, validateObjectLiteral, validateOnly, validatePredicateIRI, validateSubjectIRI, wouldPassHooks };