@marvalt/digivalt-core 0.2.0 → 0.2.3

package/CHANGELOG.md

@@ -5,6 +5,28 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.3] - 2026-04-03
+
+### Changed
+- Dependencies: `@marvalt/wadapter` ^2.3.57 (aligned with npm publish). `@marvalt/madapter` remains `^2.3.7` (includes **2.3.8** once that patch is published).
+
+## [0.2.2] - 2026-04-03
+
+### Changed
+- `useStaticDataInfo` default `frontend_id` / `frontend_name` when env vars are unset: use `default` and `DigiValt` instead of the removed legacy app id (aligns with WordPress “Default Frontend” slug and current repo layout).
+
+## [0.2.1] - 2026-03-30
+
+### Changed
+- Upgraded `digivalt-init` from a template copier into a preflight tool that inspects DigiVAlt wiring in existing Lovable/Vite apps.
+- Added safe `package.json` patching for `generate`, `build`, and `build:dev` when apps are still on plain Vite scripts.
+- Added stale `scripts/generate.ts` refresh for known DigiVAlt-managed legacy versions.
+- Added warnings for legacy workarounds such as alias-link scripts, old root generator imports, and Vite `noExternal` compatibility hacks.
+- Expanded smoke coverage for fresh installs, upgrades, idempotent reruns, custom build scripts, and dry-run previews.
+
+### Migration Notes
+- Rerun `npx digivalt-init` after upgrading to `0.2.1` so existing apps can pick up the improved build wiring checks and warnings.
+
 ## [0.2.0] - 2026-02-19
 
 ### Changed
@@ -22,7 +44,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 - Initial scaffolding of `@marvalt/digivalt-core` NPM package
-- Ported static data generation and environment configuration from `digivalt-core-v1`
+- Ported static data generation and environment configuration from the former monolithic DigiValt app (legacy `digivalt-core-v1`)
 - Integrated runtime logic and service adapters (`suitecrm`, `mautic`, `wordpress`, `gravityForms`)
 - Consolidated dynamic hooks (`useCaseStudies`, `useMautic`, `useSuiteCRM`, `useWordPressData`, etc.)
 - Exported base UI organisms and molecule components configured to work with the overarching app Shadcn UI elements

package/README.md

@@ -8,6 +8,8 @@ Core DigiVAlt package for static data generation, runtime service wiring, and Cl
 npm install @marvalt/digivalt-core
 ```
 
+In the **DigiValt monorepo**, **`digivalt-landing`** is the reference Vite app used to test this package with WordPress plugins and Cloudflare Pages.
+
 ## Entry Points
 
 Prefer explicit subpath imports so Node/build-time code does not pull browser runtime modules:
@@ -23,12 +25,27 @@ The root package export remains as a thin compatibility layer for generator-focu
 
 ## Init Workflow
 
-Run `npx digivalt-init` inside a Vite/Lovable app root. The command now validates the target folder before copying templates.
+Run `npx digivalt-init` inside a Vite/Lovable app root. The command now validates the target folder, inspects existing DigiVAlt wiring, and patches safe cases automatically.
 
 Useful flags:
 
 - `--target <path>` to initialize a different app folder
 - `--dry-run` to preview copied files without writing anything
+- `--force-template` to overwrite DigiVAlt-managed template files intentionally
+
+What init now does:
+
+- copies missing template files into the app
+- adds or updates `generate`, `build`, and `build:dev` scripts when the app is still on plain Vite wiring
+- refreshes `scripts/generate.ts` when it matches an older DigiVAlt-managed version
+- warns instead of overwriting custom build logic or custom generator scripts
+- reports stale legacy workarounds such as alias-link scripts and old root package generator imports
+
+When to rerun it:
+
+- after first installing DigiVAlt in a fresh app
+- after upgrading `@marvalt/digivalt-core` when scaffolded build wiring changes
+- before publishing a new app if you want a quick preflight of the DigiVAlt setup
 
 ## Cloudflare Secrets
 

package/bin/init.cjs

@@ -6,19 +6,65 @@ const path = require('path');
 const sourceDir = path.join(__dirname, '..', 'template');
 const args = process.argv.slice(2);
 
+const EXPECTED_GENERATE_SCRIPT =
+  'npx vite-node --options.deps.inline="@marvalt/digivalt-core/generators" scripts/generate.ts';
+const EXPECTED_BUILD_SCRIPT = `${EXPECTED_GENERATE_SCRIPT} && vite build`;
+const EXPECTED_BUILD_DEV_SCRIPT = `${EXPECTED_GENERATE_SCRIPT} && vite build --mode development`;
+
+const TEMPLATE_MANAGED_FILES = new Set([
+  '.dev.vars.example',
+  'DIGIVALT_SETUP.md',
+  'functions/api/fetch-with-access.ts',
+  'functions/api/gravity-forms-submit.ts',
+  'functions/api/mautic-submit.ts',
+  'functions/api/webhook.js',
+  'scripts/deploy-secrets.js',
+  'scripts/generate.ts',
+  'wrangler.toml',
+]);
+
+const LEGACY_GENERATE_MARKERS = [
+  "import { generators } from '@marvalt/digivalt-core';",
+  'const gfSuccess = await generators.generateGravityFormsData();',
+  'const mauticSuccess = await generators.generateMauticData();',
+  "import dotenv from 'dotenv';",
+  'dotenv.config();',
+];
+
+const LEGACY_BUILD_MARKERS = [
+  'link-digivalt-alias',
+  '@marvalt/digivalt-core',
+];
+
 function getArgValue(flag) {
   const index = args.indexOf(flag);
   return index >= 0 ? args[index + 1] : undefined;
 }
 
 const dryRun = args.includes('--dry-run');
+const forceTemplate = args.includes('--force-template');
 const explicitTarget = getArgValue('--target');
 const targetDir = path.resolve(explicitTarget || process.cwd());
 
-console.log('🚀 Initializing DigiVAlt Cloudflare Proxy Templates...');
-console.log(`📁 Target directory: ${targetDir}`);
-if (dryRun) {
-  console.log('🧪 Dry run enabled. No files will be written.');
+const report = {
+  copied: [],
+  overwritten: [],
+  skipped: [],
+  patchedScripts: [],
+  refreshedFiles: [],
+  warnings: [],
+  manualActions: [],
+};
+
+function logHeader() {
+  console.log('🚀 Initializing DigiVAlt Cloudflare Proxy Templates...');
+  console.log(`📁 Target directory: ${targetDir}`);
+  if (dryRun) {
+    console.log('🧪 Dry run enabled. No files will be written.');
+  }
+  if (forceTemplate) {
+    console.log('♻️ Force template mode enabled for DigiVAlt-managed files.');
+  }
 }
 
 function ensureValidTarget(dir) {
@@ -37,41 +83,341 @@ function ensureValidTarget(dir) {
       'No package.json found in the target directory. Run `digivalt-init` inside a Vite/Lovable app root, or pass `--target <app-path>`.'
     );
   }
+
+  return packageJsonPath;
+}
+
+function normalizeLineEndings(value) {
+  return value.replace(/\r\n/g, '\n').trim();
+}
+
+function normalizeScript(value) {
+  return String(value || '')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function readTextIfExists(filePath) {
+  return fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf8') : null;
 }
 
-function copyRecursiveSync(src, dest) {
-  const exists = fs.existsSync(src);
-  const stats = exists && fs.statSync(src);
-  const isDirectory = exists && stats.isDirectory();
-  
-  if (isDirectory) {
-    if (!fs.existsSync(dest) && !dryRun) fs.mkdirSync(dest, { recursive: true });
-    fs.readdirSync(src).forEach((childItemName) => {
-      copyRecursiveSync(path.join(src, childItemName), path.join(dest, childItemName));
+function writeFileWithMode(filePath, content) {
+  if (!dryRun) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, content);
+  }
+}
+
+function relativeDisplay(filePath) {
+  const relativePath = path.relative(targetDir, filePath).replace(/\\/g, '/');
+  return relativePath ? `/${relativePath}` : '/';
+}
+
+function listTemplateFiles(dir, baseDir = dir) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  const results = [];
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...listTemplateFiles(fullPath, baseDir));
+      continue;
+    }
+
+    results.push({
+      src: fullPath,
+      relativePath: path.relative(baseDir, fullPath).replace(/\\/g, '/'),
     });
+  }
+
+  return results;
+}
+
+function isKnownLegacyGenerateScript(content) {
+  if (!content) return false;
+  return LEGACY_GENERATE_MARKERS.some((marker) => content.includes(marker));
+}
+
+function isCurrentGenerateScript(content, templateContent) {
+  if (!content) return false;
+  return normalizeLineEndings(content) === normalizeLineEndings(templateContent);
+}
+
+function scriptRunsGenerate(command) {
+  const normalized = normalizeScript(command);
+  return normalized.includes('scripts/generate.ts') || normalized.includes('npm run generate');
+}
+
+function isExpectedBuildScript(command) {
+  return normalizeScript(command) === normalizeScript(EXPECTED_BUILD_SCRIPT);
+}
+
+function isExpectedBuildDevScript(command) {
+  return normalizeScript(command) === normalizeScript(EXPECTED_BUILD_DEV_SCRIPT);
+}
+
+function isPlainViteBuild(command) {
+  return normalizeScript(command) === 'vite build';
+}
+
+function isPlainViteBuildDev(command) {
+  return normalizeScript(command) === 'vite build --mode development';
+}
+
+function isLegacyGenerateCommand(command) {
+  const normalized = normalizeScript(command);
+  return normalized === 'vite-node scripts/generate.ts' || normalized === 'npx vite-node scripts/generate.ts';
+}
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function writeJson(filePath, value) {
+  const content = `${JSON.stringify(value, null, 2)}\n`;
+  if (!dryRun) {
+    fs.writeFileSync(filePath, content);
+  }
+}
+
+function inspectTargetApp(targetPackageJsonPath, templateGenerateScript) {
+  const packageJson = readJson(targetPackageJsonPath);
+  const scripts = packageJson.scripts || {};
+  const deps = packageJson.dependencies || {};
+  const devDeps = packageJson.devDependencies || {};
+  const generateScriptPath = path.join(targetDir, 'scripts', 'generate.ts');
+  const generateScriptContent = readTextIfExists(generateScriptPath);
+  const viteConfigCandidates = ['vite.config.ts', 'vite.config.js', 'vite.config.mts', 'vite.config.mjs'];
+  const legacyViteConfigs = [];
+
+  for (const candidate of viteConfigCandidates) {
+    const configPath = path.join(targetDir, candidate);
+    const content = readTextIfExists(configPath);
+    if (!content) continue;
+
+    if (content.includes('noExternal') && content.includes('@marvalt/digivalt-core')) {
+      legacyViteConfigs.push(candidate);
+    }
+  }
+
+  const legacyHackFiles = [];
+  const aliasLinkPath = path.join(targetDir, 'scripts', 'link-digivalt-alias.cjs');
+  if (fs.existsSync(aliasLinkPath)) {
+    legacyHackFiles.push('scripts/link-digivalt-alias.cjs');
+  }
+
+  const postinstall = scripts.postinstall || '';
+  const generateState = !generateScriptContent
+    ? 'missing'
+    : isCurrentGenerateScript(generateScriptContent, templateGenerateScript)
+      ? 'current'
+      : isKnownLegacyGenerateScript(generateScriptContent)
+        ? 'legacy'
+        : 'custom';
+
+  return {
+    packageJson,
+    packageJsonPath: targetPackageJsonPath,
+    scripts,
+    generateScriptPath,
+    generateState,
+    hasViteNode: Boolean(deps['vite-node'] || devDeps['vite-node']),
+    buildState: isExpectedBuildScript(scripts.build)
+      ? 'current'
+      : isPlainViteBuild(scripts.build)
+        ? 'plain'
+        : scriptRunsGenerate(scripts.build)
+          ? 'custom-digivalt'
+          : scripts.build
+            ? 'custom'
+            : 'missing',
+    buildDevState: isExpectedBuildDevScript(scripts['build:dev'])
+      ? 'current'
+      : isPlainViteBuildDev(scripts['build:dev'])
+        ? 'plain'
+        : scriptRunsGenerate(scripts['build:dev'])
+          ? 'custom-digivalt'
+          : scripts['build:dev']
+            ? 'custom'
+            : 'missing',
+    generateCommandState: normalizeScript(scripts.generate) === normalizeScript(EXPECTED_GENERATE_SCRIPT)
+      ? 'current'
+      : isLegacyGenerateCommand(scripts.generate)
+        ? 'legacy'
+        : scripts.generate
+          ? 'custom'
+          : 'missing',
+    legacyHackFiles,
+    legacyPostinstall: postinstall.includes('link-digivalt-alias'),
+    legacyRootImport: Boolean(generateScriptContent && generateScriptContent.includes("import { generators } from '@marvalt/digivalt-core';")),
+    legacyViteConfigs,
+  };
+}
+
+function printPreflight(status) {
+  console.log('\n🔎 Preflight');
+  console.log(`- vite-node installed: ${status.hasViteNode ? 'yes' : 'no'}`);
+  console.log(`- scripts.generate: ${status.generateCommandState}`);
+  console.log(`- scripts.build: ${status.buildState}`);
+  console.log(`- scripts.build:dev: ${status.buildDevState}`);
+  console.log(`- scripts/generate.ts: ${status.generateState}`);
+
+  if (status.legacyHackFiles.length > 0 || status.legacyPostinstall || status.legacyRootImport || status.legacyViteConfigs.length > 0) {
+    console.log('- legacy DigiVAlt wiring detected: yes');
   } else {
-    // We only copy if it doesn't already exist to prevent overwriting user changes!
-    if (fs.existsSync(dest)) {
-      console.log(`⚠️ Skipping ${dest.replace(targetDir, '')} (Already exists)`);
+    console.log('- legacy DigiVAlt wiring detected: no');
+  }
+}
+
+function patchPackageJson(status) {
+  const packageJson = status.packageJson;
+  const scripts = { ...(packageJson.scripts || {}) };
+  let changed = false;
+
+  if (!status.hasViteNode) {
+    report.manualActions.push('Install `vite-node` in the app if it is not already available, because DigiVAlt build wiring depends on it.');
+  }
+
+  if (status.generateCommandState === 'missing') {
+    scripts.generate = EXPECTED_GENERATE_SCRIPT;
+    report.patchedScripts.push('Added `scripts.generate`.');
+    changed = true;
+  } else if (status.generateCommandState === 'legacy') {
+    scripts.generate = EXPECTED_GENERATE_SCRIPT;
+    report.patchedScripts.push('Updated `scripts.generate` to the DigiVAlt generators subpath.');
+    changed = true;
+  } else if (status.generateCommandState === 'custom') {
+    report.manualActions.push('Review `scripts.generate` manually because it does not match the current DigiVAlt command.');
+  }
+
+  if (status.buildState === 'missing' || status.buildState === 'plain') {
+    scripts.build = EXPECTED_BUILD_SCRIPT;
+    report.patchedScripts.push(status.buildState === 'missing' ? 'Added `scripts.build`.' : 'Updated `scripts.build` to run static generation before `vite build`.');
+    changed = true;
+  } else if (status.buildState === 'custom') {
+    report.manualActions.push('Review `scripts.build` manually because it contains custom logic and was left unchanged.');
+  }
+
+  if (status.buildDevState === 'missing' || status.buildDevState === 'plain') {
+    scripts['build:dev'] = EXPECTED_BUILD_DEV_SCRIPT;
+    report.patchedScripts.push(status.buildDevState === 'missing' ? 'Added `scripts.build:dev`.' : 'Updated `scripts.build:dev` to run static generation before the development build.');
+    changed = true;
+  } else if (status.buildDevState === 'custom') {
+    report.manualActions.push('Review `scripts.build:dev` manually because it contains custom logic and was left unchanged.');
+  }
+
+  if (changed) {
+    packageJson.scripts = scripts;
+    writeJson(status.packageJsonPath, packageJson);
+  }
+}
+
+function reconcileGenerateScript(status, templateGenerateScript) {
+  const filePath = status.generateScriptPath;
+
+  if (status.generateState === 'missing') {
+    writeFileWithMode(filePath, templateGenerateScript);
+    report.refreshedFiles.push('Created `scripts/generate.ts` from the DigiVAlt template.');
+    return;
+  }
+
+  if (status.generateState === 'legacy' || (forceTemplate && TEMPLATE_MANAGED_FILES.has('scripts/generate.ts'))) {
+    writeFileWithMode(filePath, templateGenerateScript);
+    report.refreshedFiles.push('Refreshed `scripts/generate.ts` to the current DigiVAlt template.');
+    return;
+  }
+
+  if (status.generateState === 'custom') {
+    report.manualActions.push('Review `scripts/generate.ts` manually because it contains custom logic and was left unchanged.');
+  }
+}
+
+function copyTemplateFiles() {
+  const templateFiles = listTemplateFiles(sourceDir);
+
+  for (const file of templateFiles) {
+    if (file.relativePath === 'scripts/generate.ts') {
+      continue;
+    }
+
+    const destination = path.join(targetDir, file.relativePath);
+    const alreadyExists = fs.existsSync(destination);
+    const shouldOverwrite = alreadyExists && forceTemplate && TEMPLATE_MANAGED_FILES.has(file.relativePath);
+
+    if (alreadyExists && !shouldOverwrite) {
+      report.skipped.push(`Skipped ${relativeDisplay(destination)} (already exists).`);
+      continue;
+    }
+
+    const content = fs.readFileSync(file.src, 'utf8');
+    writeFileWithMode(destination, content);
+
+    if (alreadyExists) {
+      report.overwritten.push(`${dryRun ? 'Would overwrite' : 'Overwrote'} ${relativeDisplay(destination)}.`);
     } else {
-      if (!dryRun) {
-        fs.copyFileSync(src, dest);
-      }
-      console.log(`✅ ${dryRun ? 'Would copy' : 'Copied'} ${dest.replace(targetDir, '')}`);
+      report.copied.push(`${dryRun ? 'Would copy' : 'Copied'} ${relativeDisplay(destination)}.`);
     }
   }
 }
 
+function collectLegacyWarnings(status) {
+  if (status.legacyHackFiles.length > 0) {
+    report.warnings.push(`Legacy alias workaround detected: ${status.legacyHackFiles.join(', ')}.`);
+  }
+
+  if (status.legacyPostinstall) {
+    report.warnings.push('`scripts.postinstall` still references `link-digivalt-alias`; review whether that workaround is still needed.');
+  }
+
+  if (status.legacyRootImport) {
+    report.warnings.push('`scripts/generate.ts` still imports `generators` from the root package instead of `@marvalt/digivalt-core/generators`.');
+  }
+
+  if (status.legacyViteConfigs.length > 0) {
+    report.warnings.push(`Legacy Vite SSR/noExternal workaround detected in: ${status.legacyViteConfigs.join(', ')}.`);
+  }
+}
+
+function printList(title, items) {
+  if (items.length === 0) {
+    return;
+  }
+
+  console.log(`\n${title}`);
+  for (const item of items) {
+    console.log(`- ${item}`);
+  }
+}
+
+function printSummary() {
+  printList('📦 Template file actions', [...report.copied, ...report.overwritten, ...report.skipped]);
+  printList('🛠️ Package wiring updates', report.patchedScripts);
+  printList('🔄 Refreshed DigiVAlt files', report.refreshedFiles);
+  printList('⚠️ Warnings', report.warnings);
+  printList('👉 Manual follow-up', report.manualActions);
+
+  console.log('\n🎉 DigiVAlt init completed.');
+  console.log('Next steps:');
+  console.log('1. Review any warnings or manual follow-up items above.');
+  console.log('2. Copy `.dev.vars.example` to `.dev.vars` if you need local Wrangler secrets.');
+  console.log('3. Confirm `wrangler.toml` matches your Cloudflare Pages project name.');
+  console.log('4. Run `npm run build` to verify static generation now runs before `vite build`.');
+  console.log('5. Run `node scripts/deploy-secrets.js` when you are ready to sync allowed env vars to Cloudflare.');
+}
+
 try {
-  ensureValidTarget(targetDir);
-  copyRecursiveSync(sourceDir, targetDir);
-  console.log('\n🎉 DigiVAlt Cloudflare proxy routes installed successfully!');
-  console.log('👉 Next Steps:');
-  console.log('1. Copy .dev.vars.example to .dev.vars and add your API keys.');
-  console.log('2. Review `wrangler.toml` and confirm the Pages project name matches your app.');
-  console.log('3. Sync your production credentials to Cloudflare by running:');
-  console.log('   👉 node scripts/deploy-secrets.js');
-  console.log('4. Run `npx wrangler pages dev` to test your proxy functions locally.');
+  logHeader();
+  const packageJsonPath = ensureValidTarget(targetDir);
+  const templateGeneratePath = path.join(sourceDir, 'scripts', 'generate.ts');
+  const templateGenerateScript = fs.readFileSync(templateGeneratePath, 'utf8');
+
+  const status = inspectTargetApp(packageJsonPath, templateGenerateScript);
+  printPreflight(status);
+  collectLegacyWarnings(status);
+  patchPackageJson(status);
+  reconcileGenerateScript(status, templateGenerateScript);
+  copyTemplateFiles();
+  printSummary();
 } catch (error) {
   console.error('❌ Failed to construct templates:', error);
   process.exit(1);

package/dist/index.cjs

@@ -2487,7 +2487,7 @@ var index = /*#__PURE__*/Object.freeze({
  * Core integration library for DigiVAlt React apps
  */
 const getDigiValtVersion = () => {
-    return "0.2.0";
+    return "0.2.3";
 };
 
 exports.generateAllData = generateAllData;

package/dist/index.esm.js

@@ -2485,7 +2485,7 @@ var index = /*#__PURE__*/Object.freeze({
  * Core integration library for DigiVAlt React apps
  */
 const getDigiValtVersion = () => {
-    return "0.2.0";
+    return "0.2.3";
 };
 
 export { generateAllData, generateGravityFormsData, generateMauticData, generateSuiteCRMData, generateWordPressData, index as generators, getDigiValtVersion };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marvalt/digivalt-core",
-  "version": "0.2.0",
+  "version": "0.2.3",
   "description": "Core glue logic and shared context for DigiVAlt frontend applications",
   "license": "GPL-3.0-or-later",
   "main": "dist/index.cjs",
@@ -90,7 +90,7 @@
     "@marvalt/sadapter": "^0.1.5",
     "@marvalt/shcoder": "^0.1.35",
     "@marvalt/tadapter": "^1.0.12",
-    "@marvalt/wadapter": "^2.3.56",
+    "@marvalt/wadapter": "^2.3.57",
     "@marvalt/wparser": "^0.1.79",
     "@radix-ui/react-toast": "^1.2.15",
     "class-variance-authority": "^0.7.1",

package/template/DIGIVALT_SETUP.md

@@ -17,7 +17,9 @@ npm install -D vite-node
 ```
 
 ## 🛠️ 2. Wire the Build Scripts
-Open your `package.json` and replace your standard `"build"` and `"dev"` hooks so they intercept the compilation phase and trigger `scripts/generate.ts`.
+`digivalt-init` now preflights your app and patches safe script cases automatically. In a standard Lovable/Vite app, it should add or update the DigiVAlt build wiring for you.
+
+Still verify your `package.json` after running init. The expected result is:
 
 Change them exactly to this:
 ```json
@@ -59,4 +61,13 @@ node scripts/deploy-secrets.js
 ```
 3. If the script fails, fix the reported Wrangler or project-name issue before deploying.
 
+## 🔁 5. Rerunning Init Later
+Rerun `npx digivalt-init` after upgrading `@marvalt/digivalt-core` when DigiVAlt-managed scaffolding changes.
+
+Init will:
+- patch safe `package.json` script cases automatically
+- refresh older DigiVAlt-managed `scripts/generate.ts` files
+- warn instead of overwriting custom build logic or custom generator scripts
+- report stale legacy workarounds that may no longer be needed
+
 You are fully onboarded and ready to develop offline!