openlinear 0.1.3

package/README.md

@@ -0,0 +1,97 @@
+# OpenLinear
+
+OpenLinear launcher, installer, and validation utilities.
+
+## Installation
+
+```bash
+npm install -g openlinear
+```
+
+## Usage
+
+### CLI Launcher
+
+```bash
+openlinear
+```
+
+### Programmatic API
+
+```typescript
+import { 
+  validateExecutionMetadataSync,
+  safeValidateExecutionMetadataSync,
+  FORBIDDEN_SYNC_FIELDS,
+  isLocalExecutionEnabled,
+  parseFeatureFlags 
+} from 'openlinear';
+
+// Validate execution metadata
+const result = safeValidateExecutionMetadataSync({
+  taskId: 'tsk_123',
+  runId: 'run_456',
+  status: 'completed',
+  durationMs: 45000
+});
+
+if (result.success) {
+  console.log('Valid metadata:', result.data);
+} else {
+  console.error('Validation failed:', result.error);
+}
+
+// Check feature flags
+const flags = parseFeatureFlags();
+const localEnabled = isLocalExecutionEnabled('user-123', flags);
+```
+
+## Exports
+
+### Main (`openlinear`)
+
+- `validateExecutionMetadataSync` - Validate metadata payload
+- `safeValidateExecutionMetadataSync` - Safe validation that returns result
+- `FORBIDDEN_SYNC_FIELDS` - List of fields that cannot be synced
+- `isForbiddenField` - Check if a field is forbidden
+- `sanitizePayload` - Remove forbidden fields from payload
+- `parseFeatureFlags` - Parse feature flags from environment
+- `isLocalExecutionEnabled` - Check if local execution is enabled
+- `getMigrationPhase` - Get current migration phase
+
+### Types (`openlinear/types`)
+
+- `ExecutionMetadataSync` - Type for execution metadata
+- `ExecutionMetadataSyncSchema` - Zod schema for validation
+- `ExecutionStatus` - Execution status enum
+- `ErrorCategory` - Error category enum
+
+### Validation (`openlinear/validation`)
+
+- `checkExecutionMetadataSync` - Check if payload is valid
+- `isForbiddenField` - Check if field is forbidden
+- `sanitizePayload` - Sanitize payload by removing forbidden fields
+- `FORBIDDEN_SYNC_FIELDS` - Array of forbidden field names
+
+### Config (`openlinear/config`)
+
+- `parseFeatureFlags` - Parse feature flags
+- `getFeatureFlags` - Get feature flags from environment
+- `isLocalExecutionEnabled` - Check local execution for user
+- `isServerExecutionEnabled` - Check server execution
+- `validateFlagConfiguration` - Validate flag config
+- `getMigrationPhase` - Get migration phase
+
+## Security
+
+This package enforces the trust-boundary policy:
+
+- **Cloud-Allowed**: taskId, status, durationMs, progress, branch, prUrl, etc.
+- **Local-Only**: accessToken, apiKey, repoPath, etc.
+- **Forbidden**: prompt, logs, toolLogs, executionLogs, etc.
+
+See [docs/security/trust-boundary.md](docs/security/trust-boundary.md) for full policy.
+
+## License
+
+MIT

package/bin/openlinear.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+const { spawn } = require('node:child_process');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const appImagePath = path.join(os.homedir(), '.openlinear', 'openlinear.AppImage');
+
+if (!fs.existsSync(appImagePath)) {
+  console.error('OpenLinear AppImage not found.');
+  console.error('Run: npm install -g @kaizen403/openlinear to download it.');
+  process.exit(1);
+}
+
+const child = spawn(appImagePath, process.argv.slice(2), {
+  stdio: 'inherit'
+});
+
+child.on('exit', (code) => {
+  process.exit(code ?? 0);
+});

package/dist/chunk-5E4TN2YB.mjs

@@ -0,0 +1,87 @@
+// src/config/feature-flags.ts
+import { z } from "zod";
+var FeatureFlagsSchema = z.object({
+  LOCAL_EXECUTION_ENABLED: z.enum(["true", "false"]).default("false").transform((v) => v === "true"),
+  SERVER_EXECUTION_ENABLED: z.enum(["true", "false"]).default("true").transform((v) => v === "true"),
+  CANARY_PERCENTAGE: z.string().default("0").transform((v) => parseInt(v, 10)).refine((v) => v >= 0 && v <= 100, {
+    message: "CANARY_PERCENTAGE must be between 0 and 100"
+  }),
+  FORCE_LOCAL_EXECUTION: z.enum(["true", "false"]).default("false").transform((v) => v === "true"),
+  KILL_SWITCH_LOCAL_EXECUTION: z.enum(["true", "false"]).default("false").transform((v) => v === "true")
+});
+function parseFeatureFlags(env = process.env) {
+  return FeatureFlagsSchema.parse(env);
+}
+function getFeatureFlags() {
+  return parseFeatureFlags();
+}
+function isLocalExecutionEnabled(userId, flags = getFeatureFlags()) {
+  if (flags.KILL_SWITCH_LOCAL_EXECUTION) {
+    return false;
+  }
+  if (flags.FORCE_LOCAL_EXECUTION) {
+    return true;
+  }
+  if (!flags.LOCAL_EXECUTION_ENABLED) {
+    return false;
+  }
+  if (flags.CANARY_PERCENTAGE >= 100) {
+    return true;
+  }
+  if (flags.CANARY_PERCENTAGE <= 0) {
+    return false;
+  }
+  const hash = hashString(userId);
+  const userPercentage = hash % 100 + 1;
+  return userPercentage <= flags.CANARY_PERCENTAGE;
+}
+function isServerExecutionEnabled(flags = getFeatureFlags()) {
+  return flags.SERVER_EXECUTION_ENABLED;
+}
+function validateFlagConfiguration(flags) {
+  const errors = [];
+  if (flags.FORCE_LOCAL_EXECUTION && flags.KILL_SWITCH_LOCAL_EXECUTION) {
+    errors.push("Cannot enable both FORCE_LOCAL_EXECUTION and KILL_SWITCH_LOCAL_EXECUTION");
+  }
+  if (!flags.LOCAL_EXECUTION_ENABLED && !flags.SERVER_EXECUTION_ENABLED) {
+    errors.push("At least one execution mode must be enabled");
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function hashString(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash);
+}
+function getMigrationPhase(flags = getFeatureFlags()) {
+  if (flags.KILL_SWITCH_LOCAL_EXECUTION) {
+    return "rollback";
+  }
+  if (!flags.SERVER_EXECUTION_ENABLED) {
+    return "cutover";
+  }
+  if (flags.LOCAL_EXECUTION_ENABLED && flags.CANARY_PERCENTAGE > 0) {
+    return "canary";
+  }
+  if (flags.LOCAL_EXECUTION_ENABLED && flags.CANARY_PERCENTAGE === 0) {
+    return "shadow";
+  }
+  return "unknown";
+}
+
+export {
+  FeatureFlagsSchema,
+  parseFeatureFlags,
+  getFeatureFlags,
+  isLocalExecutionEnabled,
+  isServerExecutionEnabled,
+  validateFlagConfiguration,
+  getMigrationPhase
+};

package/dist/chunk-HARBMOVK.mjs

@@ -0,0 +1,107 @@
+// src/types/execution-metadata.ts
+import { z } from "zod";
+var ErrorCategory = z.enum([
+  "AUTH",
+  "RATE_LIMIT",
+  "MERGE_CONFLICT",
+  "TIMEOUT",
+  "UNKNOWN"
+]);
+var ExecutionStatus = z.enum([
+  "pending",
+  "running",
+  "completed",
+  "failed",
+  "cancelled"
+]);
+var ExecutionMetadataSyncSchema = z.object({
+  taskId: z.string(),
+  runId: z.string(),
+  status: ExecutionStatus,
+  startedAt: z.string().datetime().optional(),
+  completedAt: z.string().datetime().optional(),
+  durationMs: z.number().int().min(0).optional(),
+  progress: z.number().int().min(0).max(100).optional(),
+  branch: z.string().optional(),
+  commitSha: z.string().optional(),
+  prUrl: z.string().url().optional(),
+  prNumber: z.number().int().positive().optional(),
+  outcome: z.string().max(500).optional(),
+  errorCategory: ErrorCategory.optional(),
+  filesChanged: z.number().int().min(0).optional(),
+  toolsExecuted: z.number().int().min(0).optional()
+}).strict();
+function validateExecutionMetadataSync(payload) {
+  return ExecutionMetadataSyncSchema.parse(payload);
+}
+function safeValidateExecutionMetadataSync(payload) {
+  const result = ExecutionMetadataSyncSchema.safeParse(payload);
+  if (result.success) {
+    return { success: true, data: result.data };
+  } else {
+    return { success: false, error: result.error };
+  }
+}
+function checkExecutionMetadataSync(payload) {
+  const result = ExecutionMetadataSyncSchema.safeParse(payload);
+  if (result.success) {
+    return { valid: true };
+  } else {
+    return {
+      valid: false,
+      issues: result.error.errors.map(
+        (e) => `${e.path.join(".")}: ${e.message}`
+      )
+    };
+  }
+}
+function validateExecutionMetadataMiddleware() {
+  return (req, res, next) => {
+    const result = safeValidateExecutionMetadataSync(req.body);
+    if (!result.success) {
+      const hasUnknownKeys = result.error.errors.some(
+        (e) => e.message.includes("Unrecognized key") || e.code === "unrecognized_keys"
+      );
+      return res.status(400).json({
+        error: "Invalid sync payload",
+        code: hasUnknownKeys ? "FORBIDDEN_FIELDS" : "VALIDATION_ERROR",
+        details: result.error.errors.map((e) => ({
+          field: e.path.join("."),
+          message: e.message
+        }))
+      });
+    }
+    req.validatedMetadata = result.data;
+    next();
+  };
+}
+var FORBIDDEN_SYNC_FIELDS = [
+  "prompt",
+  "logs",
+  "toolLogs",
+  "executionLogs",
+  "repoPath",
+  "accessToken",
+  "apiKey",
+  "passwordHash",
+  "jwt",
+  "client",
+  "timeoutId",
+  "rawOutput",
+  "diff",
+  "fileContents",
+  "env",
+  "environment",
+  "processEnv"
+];
+
+export {
+  ErrorCategory,
+  ExecutionStatus,
+  ExecutionMetadataSyncSchema,
+  validateExecutionMetadataSync,
+  safeValidateExecutionMetadataSync,
+  checkExecutionMetadataSync,
+  validateExecutionMetadataMiddleware,
+  FORBIDDEN_SYNC_FIELDS
+};

package/dist/chunk-P3FFNK6N.mjs

@@ -0,0 +1,103 @@
+// src/validation/security.ts
+import { z } from "zod";
+var ErrorCategory = z.enum([
+  "AUTH",
+  "RATE_LIMIT",
+  "MERGE_CONFLICT",
+  "TIMEOUT",
+  "UNKNOWN"
+]);
+var ExecutionStatus = z.enum([
+  "pending",
+  "running",
+  "completed",
+  "failed",
+  "cancelled"
+]);
+var ExecutionMetadataSyncSchema = z.object({
+  taskId: z.string(),
+  runId: z.string(),
+  status: ExecutionStatus,
+  startedAt: z.string().datetime().optional(),
+  completedAt: z.string().datetime().optional(),
+  durationMs: z.number().int().min(0).optional(),
+  progress: z.number().int().min(0).max(100).optional(),
+  branch: z.string().optional(),
+  commitSha: z.string().optional(),
+  prUrl: z.string().url().optional(),
+  prNumber: z.number().int().positive().optional(),
+  outcome: z.string().max(500).optional(),
+  errorCategory: ErrorCategory.optional(),
+  filesChanged: z.number().int().min(0).optional(),
+  toolsExecuted: z.number().int().min(0).optional()
+}).strict();
+function validateExecutionMetadataSync(payload) {
+  return ExecutionMetadataSyncSchema.parse(payload);
+}
+function safeValidateExecutionMetadataSync(payload) {
+  const result = ExecutionMetadataSyncSchema.safeParse(payload);
+  if (result.success) {
+    return { success: true, data: result.data };
+  } else {
+    return { success: false, error: result.error };
+  }
+}
+function checkExecutionMetadataSync(payload) {
+  const result = ExecutionMetadataSyncSchema.safeParse(payload);
+  if (result.success) {
+    return { valid: true };
+  } else {
+    return {
+      valid: false,
+      issues: result.error.errors.map(
+        (e) => `${e.path.join(".")}: ${e.message}`
+      )
+    };
+  }
+}
+var FORBIDDEN_SYNC_FIELDS = [
+  "prompt",
+  "logs",
+  "toolLogs",
+  "executionLogs",
+  "repoPath",
+  "accessToken",
+  "apiKey",
+  "passwordHash",
+  "jwt",
+  "client",
+  "timeoutId",
+  "rawOutput",
+  "diff",
+  "fileContents",
+  "env",
+  "environment",
+  "processEnv"
+];
+function isForbiddenField(field) {
+  return FORBIDDEN_SYNC_FIELDS.includes(field);
+}
+function sanitizePayload(payload) {
+  const sanitized = {};
+  const removed = [];
+  for (const [key, value] of Object.entries(payload)) {
+    if (isForbiddenField(key)) {
+      removed.push(key);
+    } else {
+      sanitized[key] = value;
+    }
+  }
+  return { sanitized, removed };
+}
+
+export {
+  ErrorCategory,
+  ExecutionStatus,
+  ExecutionMetadataSyncSchema,
+  validateExecutionMetadataSync,
+  safeValidateExecutionMetadataSync,
+  checkExecutionMetadataSync,
+  FORBIDDEN_SYNC_FIELDS,
+  isForbiddenField,
+  sanitizePayload
+};

package/dist/config/index.d.mts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+
+declare const FeatureFlagsSchema: z.ZodObject<{
+    LOCAL_EXECUTION_ENABLED: z.ZodEffects<z.ZodDefault<z.ZodEnum<["true", "false"]>>, boolean, "true" | "false" | undefined>;
+    SERVER_EXECUTION_ENABLED: z.ZodEffects<z.ZodDefault<z.ZodEnum<["true", "false"]>>, boolean, "true" | "false" | undefined>;
+    CANARY_PERCENTAGE: z.ZodEffects<z.ZodEffects<z.ZodDefault<z.ZodString>, number, string | undefined>, number, string | undefined>;
+    FORCE_LOCAL_EXECUTION: z.ZodEffects<z.ZodDefault<z.ZodEnum<["true", "false"]>>, boolean, "true" | "false" | undefined>;
+    KILL_SWITCH_LOCAL_EXECUTION: z.ZodEffects<z.ZodDefault<z.ZodEnum<["true", "false"]>>, boolean, "true" | "false" | undefined>;
+}, "strip", z.ZodTypeAny, {
+    LOCAL_EXECUTION_ENABLED: boolean;
+    SERVER_EXECUTION_ENABLED: boolean;
+    CANARY_PERCENTAGE: number;
+    FORCE_LOCAL_EXECUTION: boolean;
+    KILL_SWITCH_LOCAL_EXECUTION: boolean;
+}, {
+    LOCAL_EXECUTION_ENABLED?: "true" | "false" | undefined;
+    SERVER_EXECUTION_ENABLED?: "true" | "false" | undefined;
+    CANARY_PERCENTAGE?: string | undefined;
+    FORCE_LOCAL_EXECUTION?: "true" | "false" | undefined;
+    KILL_SWITCH_LOCAL_EXECUTION?: "true" | "false" | undefined;
+}>;
+type FeatureFlags = z.infer<typeof FeatureFlagsSchema>;
+declare function parseFeatureFlags(env?: Record<string, string | undefined>): FeatureFlags;
+declare function getFeatureFlags(): FeatureFlags;
+declare function isLocalExecutionEnabled(userId: string, flags?: FeatureFlags): boolean;
+declare function isServerExecutionEnabled(flags?: FeatureFlags): boolean;
+declare function validateFlagConfiguration(flags: FeatureFlags): {
+    valid: boolean;
+    errors: string[];
+};
+declare function getMigrationPhase(flags?: FeatureFlags): 'shadow' | 'canary' | 'cutover' | 'rollback' | 'unknown';
+
+export { type FeatureFlags, FeatureFlagsSchema, getFeatureFlags, getMigrationPhase, isLocalExecutionEnabled, isServerExecutionEnabled, parseFeatureFlags, validateFlagConfiguration };

package/dist/config/index.d.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+
+declare const FeatureFlagsSchema: z.ZodObject<{
+    LOCAL_EXECUTION_ENABLED: z.ZodEffects<z.ZodDefault<z.ZodEnum<["true", "false"]>>, boolean, "true" | "false" | undefined>;
+    SERVER_EXECUTION_ENABLED: z.ZodEffects<z.ZodDefault<z.ZodEnum<["true", "false"]>>, boolean, "true" | "false" | undefined>;
+    CANARY_PERCENTAGE: z.ZodEffects<z.ZodEffects<z.ZodDefault<z.ZodString>, number, string | undefined>, number, string | undefined>;
+    FORCE_LOCAL_EXECUTION: z.ZodEffects<z.ZodDefault<z.ZodEnum<["true", "false"]>>, boolean, "true" | "false" | undefined>;
+    KILL_SWITCH_LOCAL_EXECUTION: z.ZodEffects<z.ZodDefault<z.ZodEnum<["true", "false"]>>, boolean, "true" | "false" | undefined>;
+}, "strip", z.ZodTypeAny, {
+    LOCAL_EXECUTION_ENABLED: boolean;
+    SERVER_EXECUTION_ENABLED: boolean;
+    CANARY_PERCENTAGE: number;
+    FORCE_LOCAL_EXECUTION: boolean;
+    KILL_SWITCH_LOCAL_EXECUTION: boolean;
+}, {
+    LOCAL_EXECUTION_ENABLED?: "true" | "false" | undefined;
+    SERVER_EXECUTION_ENABLED?: "true" | "false" | undefined;
+    CANARY_PERCENTAGE?: string | undefined;
+    FORCE_LOCAL_EXECUTION?: "true" | "false" | undefined;
+    KILL_SWITCH_LOCAL_EXECUTION?: "true" | "false" | undefined;
+}>;
+type FeatureFlags = z.infer<typeof FeatureFlagsSchema>;
+declare function parseFeatureFlags(env?: Record<string, string | undefined>): FeatureFlags;
+declare function getFeatureFlags(): FeatureFlags;
+declare function isLocalExecutionEnabled(userId: string, flags?: FeatureFlags): boolean;
+declare function isServerExecutionEnabled(flags?: FeatureFlags): boolean;
+declare function validateFlagConfiguration(flags: FeatureFlags): {
+    valid: boolean;
+    errors: string[];
+};
+declare function getMigrationPhase(flags?: FeatureFlags): 'shadow' | 'canary' | 'cutover' | 'rollback' | 'unknown';
+
+export { type FeatureFlags, FeatureFlagsSchema, getFeatureFlags, getMigrationPhase, isLocalExecutionEnabled, isServerExecutionEnabled, parseFeatureFlags, validateFlagConfiguration };

package/dist/config/index.js

@@ -0,0 +1,119 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/config/index.ts
+var config_exports = {};
+__export(config_exports, {
+  FeatureFlagsSchema: () => FeatureFlagsSchema,
+  getFeatureFlags: () => getFeatureFlags,
+  getMigrationPhase: () => getMigrationPhase,
+  isLocalExecutionEnabled: () => isLocalExecutionEnabled,
+  isServerExecutionEnabled: () => isServerExecutionEnabled,
+  parseFeatureFlags: () => parseFeatureFlags,
+  validateFlagConfiguration: () => validateFlagConfiguration
+});
+module.exports = __toCommonJS(config_exports);
+
+// src/config/feature-flags.ts
+var import_zod = require("zod");
+var FeatureFlagsSchema = import_zod.z.object({
+  LOCAL_EXECUTION_ENABLED: import_zod.z.enum(["true", "false"]).default("false").transform((v) => v === "true"),
+  SERVER_EXECUTION_ENABLED: import_zod.z.enum(["true", "false"]).default("true").transform((v) => v === "true"),
+  CANARY_PERCENTAGE: import_zod.z.string().default("0").transform((v) => parseInt(v, 10)).refine((v) => v >= 0 && v <= 100, {
+    message: "CANARY_PERCENTAGE must be between 0 and 100"
+  }),
+  FORCE_LOCAL_EXECUTION: import_zod.z.enum(["true", "false"]).default("false").transform((v) => v === "true"),
+  KILL_SWITCH_LOCAL_EXECUTION: import_zod.z.enum(["true", "false"]).default("false").transform((v) => v === "true")
+});
+function parseFeatureFlags(env = process.env) {
+  return FeatureFlagsSchema.parse(env);
+}
+function getFeatureFlags() {
+  return parseFeatureFlags();
+}
+function isLocalExecutionEnabled(userId, flags = getFeatureFlags()) {
+  if (flags.KILL_SWITCH_LOCAL_EXECUTION) {
+    return false;
+  }
+  if (flags.FORCE_LOCAL_EXECUTION) {
+    return true;
+  }
+  if (!flags.LOCAL_EXECUTION_ENABLED) {
+    return false;
+  }
+  if (flags.CANARY_PERCENTAGE >= 100) {
+    return true;
+  }
+  if (flags.CANARY_PERCENTAGE <= 0) {
+    return false;
+  }
+  const hash = hashString(userId);
+  const userPercentage = hash % 100 + 1;
+  return userPercentage <= flags.CANARY_PERCENTAGE;
+}
+function isServerExecutionEnabled(flags = getFeatureFlags()) {
+  return flags.SERVER_EXECUTION_ENABLED;
+}
+function validateFlagConfiguration(flags) {
+  const errors = [];
+  if (flags.FORCE_LOCAL_EXECUTION && flags.KILL_SWITCH_LOCAL_EXECUTION) {
+    errors.push("Cannot enable both FORCE_LOCAL_EXECUTION and KILL_SWITCH_LOCAL_EXECUTION");
+  }
+  if (!flags.LOCAL_EXECUTION_ENABLED && !flags.SERVER_EXECUTION_ENABLED) {
+    errors.push("At least one execution mode must be enabled");
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function hashString(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash);
+}
+function getMigrationPhase(flags = getFeatureFlags()) {
+  if (flags.KILL_SWITCH_LOCAL_EXECUTION) {
+    return "rollback";
+  }
+  if (!flags.SERVER_EXECUTION_ENABLED) {
+    return "cutover";
+  }
+  if (flags.LOCAL_EXECUTION_ENABLED && flags.CANARY_PERCENTAGE > 0) {
+    return "canary";
+  }
+  if (flags.LOCAL_EXECUTION_ENABLED && flags.CANARY_PERCENTAGE === 0) {
+    return "shadow";
+  }
+  return "unknown";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FeatureFlagsSchema,
+  getFeatureFlags,
+  getMigrationPhase,
+  isLocalExecutionEnabled,
+  isServerExecutionEnabled,
+  parseFeatureFlags,
+  validateFlagConfiguration
+});

package/dist/config/index.mjs

@@ -0,0 +1,18 @@
+import {
+  FeatureFlagsSchema,
+  getFeatureFlags,
+  getMigrationPhase,
+  isLocalExecutionEnabled,
+  isServerExecutionEnabled,
+  parseFeatureFlags,
+  validateFlagConfiguration
+} from "../chunk-5E4TN2YB.mjs";
+export {
+  FeatureFlagsSchema,
+  getFeatureFlags,
+  getMigrationPhase,
+  isLocalExecutionEnabled,
+  isServerExecutionEnabled,
+  parseFeatureFlags,
+  validateFlagConfiguration
+};

package/dist/index.d.mts

@@ -0,0 +1,4 @@
+export { FeatureFlags, FeatureFlagsSchema, getFeatureFlags, getMigrationPhase, isLocalExecutionEnabled, isServerExecutionEnabled, parseFeatureFlags, validateFlagConfiguration } from './config/index.mjs';
+export { isForbiddenField, sanitizePayload } from './validation/index.mjs';
+export { ErrorCategory, ExecutionMetadataSync, ExecutionMetadataSyncSchema, ExecutionStatus, FORBIDDEN_SYNC_FIELDS, checkExecutionMetadataSync, safeValidateExecutionMetadataSync, validateExecutionMetadataMiddleware, validateExecutionMetadataSync } from './types/index.mjs';
+import 'zod';

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { FeatureFlags, FeatureFlagsSchema, getFeatureFlags, getMigrationPhase, isLocalExecutionEnabled, isServerExecutionEnabled, parseFeatureFlags, validateFlagConfiguration } from './config/index.js';
+export { isForbiddenField, sanitizePayload } from './validation/index.js';
+export { ErrorCategory, ExecutionMetadataSync, ExecutionMetadataSyncSchema, ExecutionStatus, FORBIDDEN_SYNC_FIELDS, checkExecutionMetadataSync, safeValidateExecutionMetadataSync, validateExecutionMetadataMiddleware, validateExecutionMetadataSync } from './types/index.js';
+import 'zod';