mlld/dist/chunk-JRTTHLAJ.mjs

mlld: llm scripting language

import { materializeDisplayValue } from './chunk-IA26UJYI.mjs';
import { isVariable } from './chunk-DUS6QZAC.mjs';
import { GuardError } from './chunk-V5XE5YB5.mjs';
import { isStructuredValue, createStructuredValueVariable, createObjectVariable, createArrayVariable, createPrimitiveVariable, createSimpleTextVariable, materializeExpressionValue, normalizeWhenShowEffect } from './chunk-RKGZ44GZ.mjs';
import { __name } from './chunk-NJQT543K.mjs';

// interpreter/utils/parameter-factory.ts
function createParameterVariable(options) {
  const { name, value, stringValue, originalVariable, allowOriginalReuse, metadataFactory } = options;
  if (originalVariable && allowOriginalReuse) {
    return {
      ...originalVariable,
      name,
      mx: {
        ...originalVariable.mx ?? {}
      },
      internal: {
        ...originalVariable.internal ?? {},
        isSystem: true,
        isParameter: true
      }
    };
  }
  const preservedValue = value !== void 0 ? value : stringValue;
  if (preservedValue === void 0) {
    return void 0;
  }
  const metadata = metadataFactory ? metadataFactory(preservedValue) : void 0;
  if (isStructuredValue(preservedValue)) {
    return createStructuredValueVariable(name, preservedValue, {
      directive: "var",
      syntax: "reference",
      hasInterpolation: false,
      isMultiLine: false
    }, metadata);
  }
  if (preservedValue !== null && typeof preservedValue === "object" && !Array.isArray(preservedValue)) {
    return createObjectVariable(name, preservedValue, true, {
      directive: "var",
      syntax: "object",
      hasInterpolation: false,
      isMultiLine: false
    }, metadata);
  }
  if (Array.isArray(preservedValue)) {
    return createArrayVariable(name, preservedValue, true, {
      directive: "var",
      syntax: "array",
      hasInterpolation: false,
      isMultiLine: false
    }, metadata);
  }
  if (typeof preservedValue === "number" || typeof preservedValue === "boolean" || preservedValue === null) {
    return createPrimitiveVariable(name, preservedValue, {
      directive: "var",
      syntax: "literal",
      hasInterpolation: false,
      isMultiLine: false
    }, metadata);
  }
  return createSimpleTextVariable(name, String(preservedValue), {
    directive: "var",
    syntax: "quoted",
    hasInterpolation: false,
    isMultiLine: false
  }, metadata);
}
__name(createParameterVariable, "createParameterVariable");
function createPipelineParameterVariable(options) {
  const { name, value, stringValue, originalVariable, allowOriginalReuse, metadataFactory, pipelineStage, isPipelineInput } = options;
  if (originalVariable && allowOriginalReuse) {
    return {
      ...originalVariable,
      name,
      mx: {
        ...originalVariable.mx ?? {}
      },
      internal: {
        ...originalVariable.internal ?? {},
        isSystem: true,
        isParameter: true,
        isPipelineParameter: Boolean(isPipelineInput),
        pipelineStage
      }
    };
  }
  const provenanceVariable = materializeExpressionValue(value, {
    name
  }) ?? (stringValue !== void 0 ? materializeExpressionValue(stringValue, {
    name
  }) : void 0);
  if (provenanceVariable) {
    return {
      ...provenanceVariable,
      internal: {
        ...provenanceVariable.internal ?? {},
        isSystem: true,
        isParameter: true,
        isPipelineParameter: Boolean(isPipelineInput),
        pipelineStage
      }
    };
  }
  const resolvedMetadataFactory = /* @__PURE__ */ __name((val) => {
    const base = metadataFactory ? metadataFactory(val) : void 0;
    return {
      ...base,
      internal: {
        ...base?.internal ?? {},
        isParameter: true,
        isPipelineParameter: Boolean(isPipelineInput),
        pipelineStage
      }
    };
  }, "resolvedMetadataFactory");
  return createParameterVariable({
    ...options,
    metadataFactory: resolvedMetadataFactory,
    origin: options.origin ?? "pipeline"
  });
}
__name(createPipelineParameterVariable, "createPipelineParameterVariable");

// interpreter/utils/transformer-result.ts
function inferStructuredType(value) {
  if (Array.isArray(value)) {
    return "array";
  }
  if (value !== null && typeof value === "object") {
    return "object";
  }
  return "json";
}
__name(inferStructuredType, "inferStructuredType");
function safeStringify(value) {
  try {
    return JSON.stringify(value, null, 2);
  } catch {
    return String(value ?? "");
  }
}
__name(safeStringify, "safeStringify");
function normalizeTransformerResult(transformerName, result) {
  if (!transformerName) {
    return {
      value: result
    };
  }
  const normalizedName = transformerName.toLowerCase();
  if (normalizedName === "json") {
    if (isStructuredValue(result)) {
      return {
        value: result
      };
    }
    if (typeof result === "string") {
      const trimmed = result.trim();
      if (trimmed) {
        try {
          const parsed = JSON.parse(result);
          const type = inferStructuredType(parsed);
          return {
            value: parsed,
            options: {
              type,
              text: result
            }
          };
        } catch {
        }
      }
      return {
        value: result
      };
    }
    if (result !== null && typeof result === "object") {
      return {
        value: result,
        options: {
          type: inferStructuredType(result),
          text: safeStringify(result)
        }
      };
    }
  }
  return {
    value: result
  };
}
__name(normalizeTransformerResult, "normalizeTransformerResult");

// interpreter/eval/guard-denial-handler.ts
async function handleExecGuardDenial(error, options) {
  if (!(error instanceof GuardError) || error.decision !== "deny") {
    return null;
  }
  const details = error.details ?? {};
  const reason = error.reason ?? details.reason ?? error.message ?? "Guard denied operation";
  const guardContext = details.guardContext;
  const guardInput = details.guardInput;
  const deniedContext = {
    denied: true,
    reason,
    guardName: details.guardName ?? null,
    guardFilter: details.guardFilter ?? null
  };
  const { evaluateWhenExpression } = await import('./when-expression-ZW53U2K2.mjs');
  const warning = formatGuardWarning(reason, deniedContext.guardFilter, deniedContext.guardName);
  const materializedWarning = materializeDisplayValue(`${warning}
`, void 0, warning);
  options.env.emitEffect("stderr", materializedWarning.text);
  if (materializedWarning.descriptor) {
    options.env.recordSecurityDescriptor(materializedWarning.descriptor);
  }
  maybeInjectGuardInputVariable(options.execEnv, guardInput ?? guardContext?.input);
  if (guardContext?.output !== void 0) {
    const existingOutput = options.execEnv.getVariable?.("output");
    if (!existingOutput && isVariable(guardContext.output)) {
      const outVar = guardContext.output;
      const clonedOutput = {
        ...outVar,
        name: "output",
        mx: {
          ...outVar.mx ?? {}
        },
        internal: {
          ...outVar.internal ?? {},
          isSystem: true,
          isParameter: true
        }
      };
      options.execEnv.setParameterVariable("output", clonedOutput);
    }
  }
  const runHandlers = /* @__PURE__ */ __name(async () => options.execEnv.withDeniedContext(deniedContext, async () => evaluateWhenExpression(options.whenExprNode, options.execEnv, void 0, {
    denyMode: true
  })), "runHandlers");
  const whenResult = guardContext ? await options.execEnv.withGuardContext(guardContext, runHandlers) : await runHandlers();
  const normalization = normalizeWhenShowEffect(whenResult.value);
  const normalizedResult = {
    ...whenResult,
    value: normalization.hadShowEffect ? void 0 : normalization.normalized
  };
  if (!normalizedResult.internal?.deniedHandlerRan) {
    return null;
  }
  return {
    ...normalizedResult,
    stderr: warning
  };
}
__name(handleExecGuardDenial, "handleExecGuardDenial");
function maybeInjectGuardInputVariable(execEnv, value) {
  if (value === void 0 || value === null) {
    return;
  }
  const existingInput = execEnv.getVariable?.("input");
  if (existingInput) {
    return;
  }
  const variable = (isVariable(value) ? value : void 0) ?? materializeExpressionValue(value, {
    name: "input"
  });
  if (!variable) {
    return;
  }
  const clonedInput = {
    ...variable,
    name: "input",
    mx: {
      ...variable.mx ?? {}
    },
    internal: {
      ...variable.internal ?? {},
      isSystem: true,
      isParameter: true
    }
  };
  execEnv.setParameterVariable("input", clonedInput);
}
__name(maybeInjectGuardInputVariable, "maybeInjectGuardInputVariable");
function formatGuardWarning(reason, filter, guardName) {
  if (reason && reason.trim().length > 0) {
    return `[Guard Warning] ${reason}`;
  }
  const identifier = guardName ?? filter ?? "operation";
  return `[Guard Warning] Guard for ${identifier} prevented operation due to policy violation`;
}
__name(formatGuardWarning, "formatGuardWarning");

export { createParameterVariable, createPipelineParameterVariable, handleExecGuardDenial, normalizeTransformerResult };
//# sourceMappingURL=chunk-JRTTHLAJ.mjs.map
//# sourceMappingURL=chunk-JRTTHLAJ.mjs.map